home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / amiga / uae-0.7.0b2 / src / gencpu.c < prev    next >
C/C++ Source or Header  |  1998-01-20  |  87KB  |  2,460 lines
  1. /*
  2.  * UAE - The Un*x Amiga Emulator
  3.  *
  4.  * MC68000 emulation generator
  5.  *
  6.  * This is a fairly stupid program that generates a lot of case labels that
  7.  * can be #included in a switch statement.
  8.  * As an alternative, it can generate functions that handle specific
  9.  * MC68000 instructions, plus a prototype header file and a function pointer
  10.  * array to look up the function for an opcode.
  11.  * Error checking is bad, an illegal table68k file will cause the program to
  12.  * call abort().
  13.  * The generated code is sometimes sub-optimal, an optimizing compiler should
  14.  * take care of this.
  15.  *
  16.  * Copyright 1995, 1996 Bernd Schmidt
  17.  */
  18.  
  19. #include "sysconfig.h"
  20. #include "sysdeps.h"
  21. #include <ctype.h>
  22.  
  23. #include "config.h"
  24. #include "options.h"
  25. #include "readcpu.h"
  26.  
  27. #define BOOL_TYPE "int"
  28.  
  29. char warning_buffer[256];
  30.  
  31. void write_log (const char *s)
  32. {
  33.     fprintf(stderr, "%s", s);
  34. }
  35.  
  36. static int *opcode_map;
  37. static int range_start[17];
  38. static unsigned long counts[65536];
  39.  
  40. static void read_counts(void)
  41. {
  42.     FILE *file;
  43.     unsigned long opcode,count, total;
  44.     char name[20];
  45.     int nr = 0, nr2 = 0, r = 0;
  46.     memset (counts, 0, sizeof counts);
  47.  
  48.     range_start[0] = 0;
  49.     file = fopen ("frequent.68k", "r");
  50.     if (file) {
  51.     fscanf (file, "Total: %lu\n", &total);
  52.     while (fscanf (file,"%lx: %lu %s\n", &opcode, &count, name) == 3) {
  53.         opcode_map[nr++] = opcode;
  54.         counts[opcode] = count;
  55.         nr2++;
  56.         if (nr2 > (nr_cpuop_funcs + 15)/16)
  57.         nr2 = 0, range_start[++r] = nr;
  58.     }
  59.     fclose (file);
  60.     }
  61.     if (nr == nr_cpuop_funcs)
  62.     return;
  63.     for (opcode = 0; opcode < 0xFFFF; opcode++) {
  64.     if (table68k[opcode].handler == -1 && table68k[opcode].mnemo != i_ILLG
  65.         && counts[opcode] == 0)
  66.     {
  67.         opcode_map[nr++] = opcode;
  68.         counts[opcode] = count;
  69.         nr2++;
  70.         if (nr2 > (nr_cpuop_funcs + 15)/16)
  71.         nr2 = 0, range_start[++r] = nr;
  72.     }
  73.     }
  74.     range_start[16] = nr_cpuop_funcs;
  75.     if (nr != nr_cpuop_funcs)
  76.     abort ();
  77. }
  78.  
  79. static char endlabelstr[80];
  80. static int endlabelno = 0;
  81.  
  82. static int n_braces = 0;
  83. static int m68k_pc_offset = 0;
  84.  
  85. static void start_brace(void)
  86. {
  87.     n_braces++;
  88.     printf("{");
  89. }
  90.  
  91. static void close_brace(void)
  92. {
  93.     assert (n_braces > 0);
  94.     n_braces--;
  95.     printf("}");
  96. }
  97.  
  98. static void finish_braces(void)
  99. {
  100.     while (n_braces > 0)
  101.     close_brace();
  102. }
  103.  
  104. static void pop_braces(int to)
  105. {
  106.     while (n_braces > to)
  107.     close_brace();
  108. }
  109.  
  110. static int bit_size(int size)
  111. {
  112.     switch(size) {
  113.      case sz_byte:    return 8;
  114.      case sz_word:    return 16;
  115.      case sz_long:    return 32;
  116.      default:
  117.     abort();
  118.     }
  119.     return 0;
  120. }
  121.  
  122. static const char *bit_mask(int size)
  123. {
  124.     switch(size) {
  125.      case sz_byte: return "0xff";
  126.      case sz_word: return "0xffff";
  127.      case sz_long: return "0xffffffff";
  128.      default:
  129.     abort();
  130.     }
  131.     return 0;
  132. }
  133.  
  134. static const char *gen_nextilong (void)
  135. {
  136.     static char buffer[80];
  137.     int r = m68k_pc_offset;
  138.     m68k_pc_offset += 4;
  139.     sprintf(buffer, "get_ilong(%d)", r);
  140.     return buffer;
  141. }
  142.  
  143. static const char *gen_nextiword (void)
  144. {
  145.     static char buffer[80];
  146.     int r = m68k_pc_offset;
  147.     m68k_pc_offset += 2;
  148.     sprintf(buffer, "get_iword(%d)", r);
  149.     return buffer;
  150. }
  151.  
  152. static const char *gen_nextibyte (void)
  153. {
  154.     static char buffer[80];
  155.     int r = m68k_pc_offset;
  156.     m68k_pc_offset += 2;
  157.     sprintf(buffer, "get_ibyte(%d)", r);
  158.     return buffer;
  159. }
  160.  
  161. static void sync_m68k_pc (void)
  162. {
  163.     if (m68k_pc_offset == 0)
  164.     return;
  165.     printf("m68k_incpc(%d);\n", m68k_pc_offset);
  166.     switch (m68k_pc_offset) {
  167.      case 0:
  168.     /*fprintf (stderr, "refilling prefetch at 0\n");*/
  169.     break;
  170.      case 2:
  171.     printf("fill_prefetch_2();\n");
  172.     break;
  173.      default:
  174.     printf("fill_prefetch_0();\n");
  175.     break;
  176.     }
  177.     m68k_pc_offset = 0;
  178. }
  179.  
  180. /* getv == 1: fetch data; getv != 0: check for odd address. If movem != 0,
  181.  * the calling routine handles Apdi and Aipi moeds. */
  182. static void genamode(amodes mode, char *reg, wordsizes size, char *name, int getv, int movem)
  183. {
  184.     start_brace ();
  185.     switch(mode) {
  186.      case Dreg:
  187.     if (movem)
  188.         abort();
  189.     if (getv == 1)
  190.         switch(size) {
  191.          case sz_byte:
  192. #ifdef AMIGA
  193.         /* sam: I don't know why gcc.2.7.2.1 produces a code worse */
  194.         /* if it is not done like that: */
  195.         printf("\tuae_s8 %s = ((uae_u8*)&m68k_dreg(regs, %s))[3];\n", name, reg);
  196. #else
  197.         printf("\tuae_s8 %s = m68k_dreg(regs, %s);\n", name, reg);
  198. #endif
  199.         break;
  200.          case sz_word:
  201. #ifdef AMIGA
  202.         printf("\tuae_s16 %s = ((uae_s16*)&m68k_dreg(regs, %s))[1];\n", name, reg);
  203. #else
  204.         printf("\tuae_s16 %s = m68k_dreg(regs, %s);\n", name, reg);
  205. #endif
  206.         break;
  207.          case sz_long:
  208.         printf("\tuae_s32 %s = m68k_dreg(regs, %s);\n", name, reg);
  209.         break;
  210.          default: abort();
  211.         }
  212.     return;
  213.      case Areg:
  214.     if (movem)
  215.         abort();
  216.     if (getv == 1)
  217.         switch(size) {
  218.          case sz_word:
  219.         printf("\tuae_s16 %s = m68k_areg(regs, %s);\n", name, reg);
  220.         break;
  221.          case sz_long:
  222.         printf("\tuae_s32 %s = m68k_areg(regs, %s);\n", name, reg);
  223.         break;
  224.          default: abort();
  225.         }
  226.     return;
  227.      case Aind:
  228.     printf("\tuaecptr %sa = m68k_areg(regs, %s);\n", name, reg);
  229.     break;
  230.      case Aipi:
  231.     printf("\tuaecptr %sa = m68k_areg(regs, %s);\n", name, reg);
  232.     break;
  233.      case Apdi:
  234.     switch(size) {
  235.      case sz_byte:
  236.         if (movem)
  237.         printf("\tuaecptr %sa = m68k_areg(regs, %s);\n", name, reg);
  238.         else
  239.         printf("\tuaecptr %sa = m68k_areg(regs, %s) - areg_byteinc[%s];\n", name, reg, reg);
  240.         break;
  241.      case sz_word:
  242.         printf("\tuaecptr %sa = m68k_areg(regs, %s) - %d;\n", name, reg, movem ? 0 : 2);
  243.         break;
  244.      case sz_long:
  245.         printf("\tuaecptr %sa = m68k_areg(regs, %s) - %d;\n", name, reg, movem ? 0 : 4);
  246.         break;
  247.      default: abort();
  248.     }
  249.     break;
  250.      case Ad16:
  251.     printf("\tuaecptr %sa = m68k_areg(regs, %s) + (uae_s32)(uae_s16)%s;\n", name, reg, gen_nextiword());
  252.     break;
  253.      case Ad8r:
  254. #if CPU_LEVEL > 1
  255.     sync_m68k_pc();
  256.     start_brace();
  257.     printf("\tuaecptr %sa = get_disp_ea(m68k_areg(regs, %s), nextiword());\n", name, reg);
  258. #else
  259.     printf("\tuaecptr %sa = get_disp_ea(m68k_areg(regs, %s), %s);\n", name, reg, gen_nextiword());
  260. #endif
  261.     break;
  262.      case PC16:
  263.     printf("\tuaecptr %sa = m68k_getpc() + %d;\n", name, m68k_pc_offset);
  264.     printf("\t%sa += (uae_s32)(uae_s16)%s;\n", name, gen_nextiword());
  265.     break;
  266.      case PC8r:
  267. #if CPU_LEVEL > 1
  268.     sync_m68k_pc();
  269.     start_brace();
  270.     printf("\tuaecptr tmppc = m68k_getpc();\n");
  271.     printf("\tuaecptr %sa = get_disp_ea(tmppc, nextiword());\n", name);
  272. #else
  273.     printf("\tuaecptr tmppc = m68k_getpc() + %d;\n", m68k_pc_offset);
  274.     printf("\tuaecptr %sa = get_disp_ea(tmppc, %s);\n", name, gen_nextiword());
  275. #endif
  276.     break;
  277.      case absw:
  278.     printf("\tuaecptr %sa = (uae_s32)(uae_s16)%s;\n", name, gen_nextiword());
  279.     break;
  280.      case absl:
  281.     printf("\tuaecptr %sa = %s;\n", name, gen_nextilong());
  282.     break;
  283.      case imm:
  284.     if (getv != 1)
  285.         abort ();
  286.     switch(size) {
  287.      case sz_byte:
  288.         printf("\tuae_s8 %s = %s;\n", name, gen_nextibyte());
  289.         break;
  290.      case sz_word:
  291.         printf("\tuae_s16 %s = %s;\n", name, gen_nextiword());
  292.         break;
  293.      case sz_long:
  294.         printf("\tuae_s32 %s = %s;\n", name, gen_nextilong());
  295.         break;
  296.      default: abort();
  297.     }
  298.     return;
  299.      case imm0:
  300.     if (getv != 1) abort();
  301.     printf("\tuae_s8 %s = %s;\n", name, gen_nextibyte());
  302.     return;
  303.      case imm1:
  304.     if (getv != 1) abort();
  305.     printf("\tuae_s16 %s = %s;\n", name, gen_nextiword());
  306.     return;
  307.      case imm2:
  308.     if (getv != 1) abort();
  309.     printf("\tuae_s32 %s = %s;\n", name, gen_nextilong());
  310.     return;
  311.      case immi:
  312.     if (getv != 1) abort();
  313.     printf("\tuae_u32 %s = %s;\n", name, reg);
  314.     return;
  315.      default:
  316.     abort();
  317.     }
  318.  
  319.     /* We get here for all non-reg non-immediate addressing modes to
  320.      * actually fetch the value. */
  321.  
  322. #ifndef NO_EXCEPTION_3
  323.     if (getv != 0 && size != sz_byte) {
  324.     printf("\tif (!check_addr (%sa)) {\n", name);
  325.     printf("\t\tlast_fault_for_exception_3 = %sa;\n", name);
  326.     printf("\t\tlast_op_for_exception_3 = opcode;\n", name);
  327.     printf("\t\tlast_addr_for_exception_3 = m68k_getpc() + %d;\n", m68k_pc_offset);
  328.     printf("\t\tException(3, 0);\n");
  329.     printf("\t\tgoto %s;\n", endlabelstr);
  330.     printf("\t}\n");
  331.     start_brace();
  332.     }
  333. #endif
  334.  
  335.     if (getv == 1) {
  336.     start_brace ();
  337.     switch(size) {
  338.      case sz_byte:
  339.         printf("\tuae_s8 %s = get_byte(%sa);\n", name, name);
  340.         break;
  341.      case sz_word:
  342.         printf("\tuae_s16 %s = get_word(%sa);\n", name, name);
  343.         break;
  344.      case sz_long:
  345.         printf("\tuae_s32 %s = get_long(%sa);\n", name, name);
  346.         break;
  347.      default: abort();
  348.     }
  349.     }
  350.     /* We now might have to fix up the register for pre-dec or post-inc
  351.      * addressing modes. */
  352.     if (!movem)
  353.     switch (mode) {
  354.      case Aipi:
  355.         switch(size) {
  356.          case sz_byte:
  357.         printf("\tm68k_areg(regs, %s) += areg_byteinc[%s];\n", reg, reg);
  358.         break;
  359.          case sz_word:
  360.         printf("\tm68k_areg(regs, %s) += 2;\n", reg);
  361.         break;
  362.          case sz_long:
  363.         printf("\tm68k_areg(regs, %s) += 4;\n", reg);
  364.         break;
  365.          default: abort();
  366.         }
  367.         break;
  368.      case Apdi:
  369.         printf("\tm68k_areg (regs, %s) = %sa;\n", reg, name);
  370.         break;
  371.      default:
  372.         break;
  373.     }
  374. }
  375.  
  376. static void genastore(char *from, amodes mode, char *reg, wordsizes size, char *to)
  377. {
  378.     switch(mode) {
  379.      case Dreg:
  380.     switch(size) {
  381.      case sz_byte:
  382.         printf("\tm68k_dreg(regs, %s) = (m68k_dreg(regs, %s) & ~0xff) | ((%s) & 0xff);\n", reg, reg, from);
  383.         break;
  384.      case sz_word:
  385.         printf("\tm68k_dreg(regs, %s) = (m68k_dreg(regs, %s) & ~0xffff) | ((%s) & 0xffff);\n", reg, reg, from);
  386.         break;
  387.      case sz_long:
  388.         printf("\tm68k_dreg(regs, %s) = (%s);\n", reg, from);
  389.         break;
  390.      default: abort();
  391.     }
  392.     break;
  393.      case Areg:
  394.     switch(size) {
  395.      case sz_word:
  396.         fprintf(stderr, "Foo\n");
  397.         printf("\tm68k_areg(regs, %s) = (uae_s32)(uae_s16)(%s);\n", reg, from);
  398.         break;
  399.      case sz_long:
  400.         printf("\tm68k_areg(regs, %s) = (%s);\n", reg, from);
  401.         break;
  402.      default: abort();
  403.     }
  404.     break;
  405.      case Aind:
  406.      case Aipi:
  407.      case Apdi:
  408.      case Ad16:
  409.      case Ad8r:
  410.      case absw:
  411.      case absl:
  412. #ifndef NO_PREFETCH_BUFFER
  413.     sync_m68k_pc();
  414. #endif
  415.     switch(size) {
  416.      case sz_byte:
  417.         printf("\tput_byte(%sa,%s);\n", to, from);
  418.         break;
  419.      case sz_word:
  420.         printf("\tput_word(%sa,%s);\n", to, from);
  421.         break;
  422.      case sz_long:
  423.         printf("\tput_long(%sa,%s);\n", to, from);
  424.         break;
  425.      default: abort();
  426.     }
  427.     break;
  428.      case PC16:
  429.      case PC8r:
  430. #ifndef NO_PREFETCH_BUFFER
  431.     sync_m68k_pc();
  432. #endif
  433.     switch(size) {
  434.      case sz_byte:
  435.         printf("\tput_byte(%sa,%s);\n", to, from);
  436.         break;
  437.      case sz_word:
  438.         if (CPU_LEVEL < 2)
  439.         abort();
  440.         printf("\tput_word(%sa,%s);\n", to, from);
  441.         break;
  442.      case sz_long:
  443.         if (CPU_LEVEL < 2)
  444.         abort();
  445.         printf("\tput_long(%sa,%s);\n", to, from);
  446.         break;
  447.      default: abort();
  448.     }
  449.     break;
  450.      case imm:
  451.      case imm0:
  452.      case imm1:
  453.      case imm2:
  454.      case immi:
  455.     abort();
  456.     break;
  457.      default:
  458.     abort();
  459.     }
  460. }
  461.  
  462. static void genmovemel(uae_u16 opcode)
  463. {
  464.     char getcode[100];
  465.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  466.  
  467.     if (table68k[opcode].size == sz_long) {
  468.     strcpy(getcode, "get_long(srca)");
  469.     } else {
  470.     strcpy(getcode, "(uae_s32)(uae_s16)get_word(srca)");
  471.     }
  472.  
  473.     printf("\tuae_u16 mask = %s;\n", gen_nextiword());
  474.     printf("\tunsigned int dmask = mask & 0xff, amask = (mask >> 8) & 0xff;\n");
  475.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 2, 1);
  476.     start_brace();
  477.     printf("\twhile (dmask) { m68k_dreg(regs, movem_index1[dmask]) = %s; srca += %d; dmask = movem_next[dmask]; }\n",
  478.         getcode, size);
  479.     printf("\twhile (amask) { m68k_areg(regs, movem_index1[amask]) = %s; srca += %d; amask = movem_next[amask]; }\n",
  480.         getcode, size);
  481.  
  482.     if (table68k[opcode].dmode == Aipi)
  483.     printf("\tm68k_areg(regs, dstreg) = srca;\n");
  484. }
  485.  
  486. static void genmovemle(uae_u16 opcode)
  487. {
  488.     char putcode[100];
  489.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  490.     if (table68k[opcode].size == sz_long) {
  491.     strcpy(putcode, "put_long(srca,");
  492.     } else {
  493.     strcpy(putcode, "put_word(srca,");
  494.     }
  495.  
  496.     printf("\tuae_u16 mask = %s;\n", gen_nextiword());
  497.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 2, 1);
  498. #ifndef NO_PREFETCH_BUFFER
  499.     sync_m68k_pc();
  500. #endif
  501.     start_brace();
  502.     if (table68k[opcode].dmode == Apdi) {
  503.     printf("\tuae_u16 amask = mask & 0xff, dmask = (mask >> 8) & 0xff;\n");
  504.     printf("\twhile (amask) { srca -= %d; %s m68k_areg(regs, movem_index2[amask])); amask = movem_next[amask]; }\n",
  505.        size, putcode);
  506.     printf("\twhile (dmask) { srca -= %d; %s m68k_dreg(regs, movem_index2[dmask])); dmask = movem_next[dmask]; }\n",
  507.        size, putcode);
  508.     printf("\tm68k_areg(regs, dstreg) = srca;\n");
  509.     } else {
  510.     printf("\tuae_u16 dmask = mask & 0xff, amask = (mask >> 8) & 0xff;\n");
  511.     printf("\twhile (dmask) { %s m68k_dreg(regs, movem_index1[dmask])); srca += %d; dmask = movem_next[dmask]; }\n",
  512.        putcode, size);
  513.     printf("\twhile (amask) { %s m68k_areg(regs, movem_index1[amask])); srca += %d; amask = movem_next[amask]; }\n",
  514.        putcode, size);
  515.     }
  516. }
  517.  
  518. typedef enum {
  519.     flag_logical, flag_add, flag_sub, flag_cmp, flag_addx, flag_subx, flag_zn,
  520.     flag_av, flag_sv
  521. } flagtypes;
  522.  
  523. static void genflags_normal(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  524. {
  525.     char vstr[100],sstr[100],dstr[100];
  526.     char usstr[100],udstr[100];
  527.     char unsstr[100],undstr[100];
  528.  
  529.     switch(size) {
  530.      case sz_byte:
  531.     strcpy(vstr, "((uae_s8)(");
  532.     strcpy(usstr, "((uae_u8)(");
  533.     break;
  534.      case sz_word:
  535.     strcpy(vstr, "((uae_s16)(");
  536.     strcpy(usstr, "((uae_u16)(");
  537.     break;
  538.      case sz_long:
  539.     strcpy(vstr, "((uae_s32)(");
  540.     strcpy(usstr, "((uae_u32)(");
  541.     break;
  542.      default:
  543.     abort();
  544.     }
  545.     strcpy(unsstr, usstr);
  546.  
  547.     strcpy(sstr, vstr);
  548.     strcpy(dstr, vstr);
  549.     strcat(vstr, value); strcat(vstr,"))");
  550.     strcat(dstr, dst); strcat(dstr,"))");
  551.     strcat(sstr, src); strcat(sstr,"))");
  552.  
  553.     strcpy(udstr, usstr);
  554.     strcat(udstr, dst); strcat(udstr,"))");
  555.     strcat(usstr, src); strcat(usstr,"))");
  556.  
  557.     strcpy(undstr, unsstr);
  558.     strcat(unsstr, "-");
  559.     strcat(undstr, "~");
  560.     strcat(undstr, dst); strcat(undstr,"))");
  561.     strcat(unsstr, src); strcat(unsstr,"))");
  562.  
  563.     switch (type) {
  564.      case flag_logical:
  565.      case flag_zn:
  566.      case flag_av:
  567.      case flag_sv:
  568.      case flag_addx:
  569.      case flag_subx:
  570.     break;
  571.  
  572.      case flag_add:
  573.     start_brace();
  574.     printf("uae_u32 %s = %s + %s;\n", value, dstr, sstr);
  575.     break;
  576.      case flag_sub:
  577.      case flag_cmp:
  578.     start_brace();
  579.     printf("uae_u32 %s = %s - %s;\n", value, dstr, sstr);
  580.     break;
  581.     }
  582.  
  583.  
  584.     switch (type) {
  585.      case flag_logical:
  586.      case flag_zn:
  587.     break;
  588.  
  589.      case flag_add:
  590.      case flag_sub:
  591.      case flag_addx:
  592.      case flag_subx:
  593.      case flag_cmp:
  594.      case flag_av:
  595.      case flag_sv:
  596.     start_brace();
  597.     printf("\t"BOOL_TYPE" flgs = %s < 0;\n", sstr);
  598.     printf("\t"BOOL_TYPE" flgo = %s < 0;\n", dstr);
  599.     printf("\t"BOOL_TYPE" flgn = %s < 0;\n", vstr);
  600.     break;
  601.     }
  602.  
  603.     switch(type) {
  604.      case flag_logical:
  605.     printf("\tVFLG = CFLG = 0;\n");
  606.     printf("\tZFLG = %s == 0;\n", vstr);
  607.     printf("\tNFLG = %s < 0;\n", vstr);
  608.     break;
  609.      case flag_av:
  610.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  611.     break;
  612.      case flag_sv:
  613.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  614.     break;
  615.      case flag_zn:
  616.     printf("\tif (%s != 0) ZFLG = 0;\n", vstr);
  617.     printf("\tNFLG = %s < 0;\n", vstr);
  618.     break;
  619.      case flag_add:
  620.     printf("\tZFLG = %s == 0;\n", vstr);
  621.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  622.     printf("\tCFLG = XFLG = %s < %s;\n", undstr, usstr);
  623.     printf("\tNFLG = flgn != 0;\n");
  624.     break;
  625.      case flag_sub:
  626.     printf("\tZFLG = %s == 0;\n", vstr);
  627.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  628.     printf("\tCFLG = XFLG = %s > %s;\n", usstr, udstr);
  629.     printf("\tNFLG = flgn != 0;\n");
  630.     break;
  631.      case flag_addx:
  632.     printf("\tVFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);\n");
  633.     printf("\tXFLG = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));\n");
  634.     break;
  635.      case flag_subx:
  636.     printf("\tVFLG = (!flgs && flgo && !flgn) || (flgs && !flgo && flgn);\n");
  637.     printf("\tXFLG = CFLG = (flgs && !flgo) || (flgn && (!flgo || flgs));\n");
  638.     break;
  639.      case flag_cmp:
  640.     printf("\tZFLG = %s == 0;\n", vstr);
  641.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  642.     printf("\tCFLG = %s > %s;\n", usstr, udstr);
  643.     printf("\tNFLG = flgn != 0;\n");
  644.     break;
  645.     }
  646. }
  647.  
  648. static void genflags(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  649. {
  650. #ifdef X86_ASSEMBLY
  651.     start_brace();
  652.     printf("\tuae_u32 scratch;\n");
  653.     switch (type) {
  654.      case flag_add: case flag_sub:
  655.     start_brace();
  656.     printf("\tuae_u32 %s;\n", value);
  657.     break;
  658.  
  659.      default:
  660.     break;
  661.     }
  662.  
  663.     /* At least some of those casts are fairly important! */
  664.     switch(type) {
  665.      case flag_logical:
  666.     if (strcmp(value, "0") == 0) {
  667.         printf("\t*(uae_u32 *)®flags = 64;\n");
  668.     } else {
  669.         switch(size) {
  670.          case sz_byte: printf("\tx86_flag_testb ((uae_s8)(%s));\n", value); break;
  671.          case sz_word: printf("\tx86_flag_testw ((uae_s16)(%s));\n", value); break;
  672.          case sz_long: printf("\tx86_flag_testl ((uae_s32)(%s));\n", value); break;
  673.         }
  674.     }
  675.     return;
  676.  
  677.      case flag_add:
  678.     switch(size) {
  679.      case sz_byte: printf("\tx86_flag_addb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
  680.      case sz_word: printf("\tx86_flag_addw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
  681.      case sz_long: printf("\tx86_flag_addl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
  682.     }
  683.     return;
  684.  
  685.      case flag_sub:
  686.     switch(size) {
  687.      case sz_byte: printf("\tx86_flag_subb (%s, (uae_s8)(%s), (uae_s8)(%s));\n", value, src, dst); break;
  688.      case sz_word: printf("\tx86_flag_subw (%s, (uae_s16)(%s), (uae_s16)(%s));\n", value, src, dst); break;
  689.      case sz_long: printf("\tx86_flag_subl (%s, (uae_s32)(%s), (uae_s32)(%s));\n", value, src, dst); break;
  690.     }
  691.     return;
  692.  
  693.      case flag_cmp:
  694.     switch(size) {
  695.      case sz_byte: printf("\tx86_flag_cmpb ((uae_s8)(%s), (uae_s8)(%s));\n", src, dst); break;
  696.      case sz_word: printf("\tx86_flag_cmpw ((uae_s16)(%s), (uae_s16)(%s));\n", src, dst); break;
  697.      case sz_long: printf("\tx86_flag_cmpl ((uae_s32)(%s), (uae_s32)(%s));\n", src, dst); break;
  698.     }
  699.     return;
  700.  
  701.      default:
  702.     break;
  703.     }
  704. #elif defined(M68K_FLAG_OPT)
  705.     /* sam: here I'm cloning what X86_ASSEMBLY does */
  706. #define EXT(size)  (size==sz_byte?"b":(size==sz_word?"w":"l"))
  707. #define CAST(size) (size==sz_byte?"uae_s8":(size==sz_word?"uae_s16":"uae_s32"))
  708.     switch (type) {
  709.      case flag_add: case flag_sub:
  710.     start_brace();
  711.     printf("\tuae_u32 %s;\n", value);
  712.     break;
  713.  
  714.      default:
  715.     break;
  716.     }
  717.  
  718.     switch(type) {
  719.      case flag_logical:
  720.     if (strcmp(value, "0") == 0) {
  721.         printf("\t*(uae_u16 *)®flags = 4;\n"); /* Z = 1 */
  722.     } else {
  723.         printf("\tm68k_flag_tst (%s, (%s)(%s));\n", 
  724.            EXT(size), CAST(size), value);
  725.     }
  726.     return;
  727.  
  728.      case flag_add:
  729.     printf("\t{uae_u16 ccr;\n");
  730.     printf("\tm68k_flag_add (%s, (%s)%s, (%s)(%s), (%s)(%s));\n", 
  731.            EXT(size), CAST(size), value, CAST(size), src, CAST(size), dst);
  732.     printf("\t((uae_u16*)®flags)[1]=((uae_u16*)®flags)[0]=ccr;}\n");
  733.     return;
  734.  
  735.      case flag_sub:
  736.     printf("\t{uae_u16 ccr;\n");
  737.     printf("\tm68k_flag_sub (%s, (%s)%s, (%s)(%s), (%s)(%s));\n", 
  738.            EXT(size), CAST(size), value, CAST(size), src, CAST(size), dst);
  739.     printf("\t((uae_u16*)®flags)[1]=((uae_u16*)®flags)[0]=ccr;}\n");
  740.     return;
  741.  
  742.      case flag_cmp:
  743.     printf("\tm68k_flag_cmp (%s, (%s)(%s), (%s)(%s));\n", 
  744.            EXT(size), CAST(size), src, CAST(size), dst);
  745.     return;
  746.  
  747.      default:
  748.     break;
  749.     }
  750. #elif defined(ACORN_FLAG_OPT) && defined(__GNUC_MINOR__)
  751. /*
  752.  * This is new. Might be quite buggy.
  753.  */
  754.   switch (type)
  755.   {
  756.     case flag_av:
  757.     case flag_sv:
  758.     case flag_zn:
  759.     case flag_addx:
  760.     case flag_subx:
  761.       break;
  762.  
  763.     case flag_logical:
  764.       if (strcmp(value, "0") == 0) {
  765.     /* v=c=n=0 z=1 */
  766.      printf("\t*(ULONG*)®flags = 0x40000000;\n");
  767.      return;
  768.       }
  769.       else
  770.       {
  771.     start_brace();
  772.     switch(size)
  773.     {
  774.       case sz_byte:
  775.         printf("\tUBYTE ccr;\n");
  776.         printf("\tULONG shift;\n");
  777.         printf("\t__asm__(\"mov %%2,%%1,lsl#24\n\ttst %%2,%%2\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
  778.            "\t: \"=r\" (ccr) : \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value);
  779.         printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  780.         return;
  781.       case sz_word:
  782.         printf("\tUBYTE ccr;\n");
  783.         printf("\tULONG shift;\n");
  784.         printf("\t__asm__(\"mov %%2,%%1,lsl#16\n\ttst %%2,%%2\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
  785.            "\t: \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value);
  786.         printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  787.         return;
  788.       case sz_long:
  789.         printf("\tUBYTE ccr;\n");
  790.         printf("\t__asm__(\"tst %%1,%%1\n\tmov %%0,r15,lsr#24\n\tbic %%0,%%0,#0x30\"\n"
  791.            "\t: \"=r\" (ccr) : \"r\" ((LONG)%s) : \"cc\" );\n", value);
  792.         printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  793.         return;
  794.     }
  795.       }
  796.       break;
  797.     case flag_add:
  798.       if(strcmp(dst,"0")==0)
  799.       {
  800.     printf("/* Error! Hier muss Peter noch was machen !!! (ADD-Flags) */");
  801.       }
  802.       else
  803.       {
  804.     start_brace();
  805.     switch (size)
  806.     {
  807.       case sz_byte:
  808.         printf("\tULONG ccr, shift, %s;\n", value);
  809.         printf("\t__asm__(\"mov %%4,%%3,lsl#24\n\tadds %%0,%%4,%%2,lsl#24\n\tmov %%0,%%0,asr#24\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
  810.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
  811.         printf("\t*(ULONG*)®flags = ccr;\n");
  812.         return;
  813.       case sz_word:
  814.         printf("\tULONG ccr, shift, %s;\n", value);
  815.         printf("\t__asm__(\"mov %%4,%%3,lsl#16\n\tadds %%0,%%4,%%2,lsl#16\n\tmov %%0,%%0,asr#16\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
  816.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
  817.         printf("\t*(ULONG*)®flags = ccr;\n");
  818.         return;
  819.       case sz_long:
  820.         printf("\tULONG ccr, %s;\n", value);
  821.         printf("\t__asm__(\"adds %%0,%%3,%%2\n\tmov %%1,r15\n\torr %%1,%%1,%%1,lsr#29\"\n"
  822.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", value, src, dst);
  823.         printf("\t*(ULONG*)®flags = ccr;\n");
  824.         return;
  825.     }
  826.       }
  827.       break;
  828.     case flag_sub:
  829.       if(strcmp(dst,"0")==0)
  830.       {
  831.     printf("/* Error! Hier muss Peter noch was machen !!! (SUB-Flags) */");
  832.       }
  833.       else
  834.       {
  835.     start_brace();
  836.     switch (size)
  837.     {
  838.       case sz_byte:
  839.         printf("\tULONG ccr, shift, %s;\n", value);
  840.         printf("\t__asm__(\"mov %%4,%%3,lsl#24\n\tsubs %%0,%%4,%%2,lsl#24\n\tmov %%0,%%0,asr#24\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
  841.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
  842.         printf("\t*(ULONG*)®flags = ccr;\n");
  843.         return;
  844.       case sz_word:
  845.         printf("\tULONG ccr, shift, %s;\n", value);
  846.         printf("\t__asm__(\"mov %%4,%%3,lsl#16\n\tsubs %%0,%%4,%%2,lsl#16\n\tmov %%0,%%0,asr#16\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
  847.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", value, src, dst);
  848.         printf("\t*(ULONG*)®flags = ccr;\n");
  849.         return;
  850.       case sz_long:
  851.         printf("\tULONG ccr, %s;\n", value);
  852.         printf("\t__asm__(\"subs %%0,%%3,%%2\n\tmov %%1,r15\n\teor %%1,%%1,#0x20000000\n\torr %%1,%%1,%%1,lsr#29\"\n"
  853.            "\t: \"=r\" (%s), \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", value, src, dst);
  854.         printf("\t*(ULONG*)®flags = ccr;\n");
  855.         return;
  856.     }
  857.       }
  858.       break;
  859.     case flag_cmp:
  860.       if(strcmp(dst,"0")==0)
  861.       {
  862.     printf("/*Error! Hier muss Peter noch was machen !!! (CMP-Flags)*/");
  863.       }
  864.       else
  865.       {
  866.     start_brace();
  867.     switch (size)
  868.     {
  869.     case sz_byte:
  870.       printf("\tULONG shift, ccr;\n");
  871.       printf("\t__asm__(\"mov %%3,%%2,lsl#24\n\tcmp %%3,%%1,lsl#24\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
  872.          "\t: \"=r\" (ccr) : \"r\" (%s), \"r\" (%s), \"r\" (shift) : \"cc\" );\n", src, dst);
  873.       printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  874.       return;
  875.     case sz_word:
  876.       printf("\tULONG shift, ccr;\n");
  877.       printf("\t__asm__(\"mov %%3,%%2,lsl#16\n\tcmp %%3,%%1,lsl#16\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
  878.          "\t: \"=r\" (ccr) : \"r\" ((WORD)%s), \"r\" ((WORD)%s), \"r\" (shift) : \"cc\" );\n", src, dst);
  879.       printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  880.       return;
  881.     case sz_long:
  882.       printf("\tULONG ccr;\n");
  883.       printf("\t__asm__(\"cmp %%2,%%1\n\tmov %%0,r15,lsr#24\n\teor %%0,%%0,#0x20\"\n"
  884.          "\t: \"=r\" (ccr) : \"r\" ((LONG)%s), \"r\" ((LONG)%s) : \"cc\" );\n", src, dst);
  885.       printf("\t*((UBYTE*)®flags+3) = ccr;\n");
  886.       /*printf("\tprintf(\"%%08x %%08x %%08x\\n\", %s, %s, *((ULONG*)®flags));\n", src, dst);*/
  887.       return;
  888.     }
  889.       }
  890.       break;
  891.   }
  892. #endif
  893.     genflags_normal(type, size, value, src, dst);
  894. }
  895.  
  896. static void gen_opcode(unsigned long int opcode)
  897. {
  898.     start_brace ();
  899. #if 0
  900. #ifdef USE_POINTER
  901.     printf("uae_u8 *m68k_pc = regs.pc_p;\n");
  902. #else
  903.     printf("uae_u32 m68k_pc = regs.pc;\n");
  904. #endif
  905. #endif
  906.     m68k_pc_offset = 2;
  907.     switch (table68k[opcode].plev) {
  908.      case 0: /* not privileged */
  909.     break;
  910.      case 1: /* unprivileged only on 68000 */
  911.     if (CPU_LEVEL == 0)
  912.         break;
  913.     /* FALLTHROUGH */
  914.      case 2: /* priviledged */
  915. #ifdef USE_POINTER
  916.     printf("if (!regs.s) { Exception(8,0); goto %s; }\n", endlabelstr);
  917. #else
  918.     printf("if (!regs.s) { Exception(8,0); goto %s; }\n", endlabelstr);
  919. #endif
  920.     start_brace();
  921.     break;
  922.      case 3: /* privileged if size == word */
  923.     if (table68k[opcode].size == sz_byte)
  924.         break;
  925. #ifdef USE_POINTER
  926.     printf("if (!regs.s) { Exception(8,0); goto %s; }\n", endlabelstr);
  927. #else
  928.     printf("if (!regs.s) { Exception(8,0); goto %s; }\n", endlabelstr);
  929. #endif
  930.     start_brace();
  931.     break;
  932.     }
  933.     switch(table68k[opcode].mnemo) {
  934.      case i_OR:
  935.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  936.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  937.     printf("\tsrc |= dst;\n");
  938.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  939.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  940.     break;
  941.      case i_AND:
  942.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  943.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  944.     printf("\tsrc &= dst;\n");
  945.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  946.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  947.     break;
  948.      case i_EOR:
  949.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  950.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  951.     printf("\tsrc ^= dst;\n");
  952.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  953.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  954.     break;
  955.      case i_ORSR:
  956.     printf("\tMakeSR();\n");
  957.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  958.     if (table68k[opcode].size == sz_byte) {
  959.         printf("\tsrc &= 0xFF;\n");
  960.     }
  961.     printf("\tregs.sr |= src;\n");
  962.     printf("\tMakeFromSR();\n");
  963.     break;
  964.      case i_ANDSR:
  965.     printf("\tMakeSR();\n");
  966.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  967.     if (table68k[opcode].size == sz_byte) {
  968.         printf("\tsrc |= 0xFF00;\n");
  969.     }
  970.     printf("\tregs.sr &= src;\n");
  971.     printf("\tMakeFromSR();\n");
  972.     break;
  973.      case i_EORSR:
  974.     printf("\tMakeSR();\n");
  975.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  976.     if (table68k[opcode].size == sz_byte) {
  977.         printf("\tsrc &= 0xFF;\n");
  978.     }
  979.     printf("\tregs.sr ^= src;\n");
  980.     printf("\tMakeFromSR();\n");
  981.     break;
  982.      case i_SUB:
  983.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  984.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  985.     start_brace ();
  986.     genflags(flag_sub, table68k[opcode].size, "newv", "src", "dst");
  987.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  988.     break;
  989.      case i_SUBA:
  990.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  991.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  992.     start_brace ();
  993.     printf("\tuae_u32 newv = dst - src;\n");
  994.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  995.     break;
  996.      case i_SUBX:
  997.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  998.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  999.     start_brace ();
  1000.     printf("\tuae_u32 newv = dst - src - (XFLG ? 1 : 0);\n");
  1001.     genflags(flag_subx, table68k[opcode].size, "newv", "src", "dst");
  1002.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1003.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1004.     break;
  1005.      case i_SBCD:
  1006.     /* Let's hope this works... */
  1007.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1008.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1009.     start_brace ();
  1010.     printf("\tuae_u16 newv_lo = (dst & 0xF) - (src & 0xF) - (XFLG ? 1 : 0);\n");
  1011.     printf("\tuae_u16 newv_hi = (dst & 0xF0) - (src & 0xF0);\n");
  1012.     printf("\tuae_u16 newv;\n");
  1013.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  1014.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  1015.     printf("\tCFLG = XFLG = (newv_hi & 0x1F0) > 0x90;\n");
  1016.     printf("\tif (CFLG) newv -= 0x60;\n");
  1017.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1018.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");
  1019.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1020.     break;
  1021.      case i_ADD:
  1022.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1023.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1024.     start_brace ();
  1025.     genflags(flag_add, table68k[opcode].size, "newv", "src", "dst");
  1026.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1027.     break;
  1028.      case i_ADDA:
  1029.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1030.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1031.     start_brace ();
  1032.     printf("\tuae_u32 newv = dst + src;\n");
  1033.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1034.     break;
  1035.      case i_ADDX:
  1036.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1037.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1038.     start_brace ();
  1039.     printf("\tuae_u32 newv = dst + src + (XFLG ? 1 : 0);\n");
  1040.     genflags(flag_addx, table68k[opcode].size, "newv", "src", "dst");
  1041.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1042.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1043.     break;
  1044.      case i_ABCD:
  1045.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1046.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1047.     start_brace ();
  1048.     printf("\tuae_u16 newv_lo = (src & 0xF) + (dst & 0xF) + (XFLG ? 1 : 0);\n");
  1049.     printf("\tuae_u16 newv_hi = (src & 0xF0) + (dst & 0xF0);\n");
  1050.     printf("\tuae_u16 newv;\n");
  1051.     printf("\tif (newv_lo > 9) { newv_lo +=6; }\n");
  1052.     printf("\tnewv = newv_hi + newv_lo;");
  1053.     printf("\tCFLG = XFLG = (newv & 0x1F0) > 0x90;\n");
  1054.     printf("\tif (CFLG) newv += 0x60;\n");
  1055.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1056.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");
  1057.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1058.     break;
  1059.      case i_NEG:
  1060.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1061.     start_brace ();
  1062.     genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
  1063.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1064.     break;
  1065.      case i_NEGX:
  1066.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1067.     start_brace ();
  1068.     printf("\tuae_u32 newv = 0 - src - (XFLG ? 1 : 0);\n");
  1069.     genflags(flag_subx, table68k[opcode].size, "newv", "src", "0");
  1070.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1071.     genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1072.     break;
  1073.      case i_NBCD:
  1074.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1075.     start_brace ();
  1076.     printf("\tuae_u16 newv_lo = - (src & 0xF) - (XFLG ? 1 : 0);\n");
  1077.     printf("\tuae_u16 newv_hi = - (src & 0xF0);\n");
  1078.     printf("\tuae_u16 newv;\n");
  1079.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  1080.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  1081.     printf("\tCFLG = XFLG = (newv_hi & 0x1F0) > 0x90;\n");
  1082.     printf("\tif (CFLG) newv -= 0x60;\n");
  1083.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1084.     genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1085.     break;
  1086.      case i_CLR:
  1087.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 2, 0);
  1088.     genflags(flag_logical, table68k[opcode].size, "0", "", "");
  1089.     genastore("0",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1090.     break;
  1091.      case i_NOT:
  1092.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1093.     start_brace ();
  1094.     printf("\tuae_u32 dst = ~src;\n");
  1095.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1096.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1097.     break;
  1098.      case i_TST:
  1099.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1100.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  1101.     break;
  1102.      case i_BTST:
  1103.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1104.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1105.     if (table68k[opcode].size == sz_byte)
  1106.         printf("\tsrc &= 7;\n");
  1107.     else
  1108.         printf("\tsrc &= 31;\n");
  1109.     printf("\tZFLG = !(dst & (1 << src));\n");
  1110.     break;
  1111.      case i_BCHG:
  1112.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1113.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1114.     if (table68k[opcode].size == sz_byte)
  1115.         printf("\tsrc &= 7;\n");
  1116.     else
  1117.         printf("\tsrc &= 31;\n");
  1118.     printf("\tZFLG = !(dst & (1 << src));\n");
  1119.     printf("\tdst ^= (1 << src);\n");
  1120.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1121.     break;
  1122.      case i_BCLR:
  1123.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1124.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1125.     if (table68k[opcode].size == sz_byte)
  1126.         printf("\tsrc &= 7;\n");
  1127.     else
  1128.         printf("\tsrc &= 31;\n");
  1129.     printf("\tZFLG = !(dst & (1 << src));\n");
  1130.     printf("\tdst &= ~(1 << src);\n");
  1131.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1132.     break;
  1133.      case i_BSET:
  1134.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1135.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1136.     if (table68k[opcode].size == sz_byte)
  1137.         printf("\tsrc &= 7;\n");
  1138.     else
  1139.         printf("\tsrc &= 31;\n");
  1140.     printf("\tZFLG = !(dst & (1 << src));\n");
  1141.     printf("\tdst |= (1 << src);\n");
  1142.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1143.     break;
  1144.      case i_CMPM:
  1145.      case i_CMP:
  1146.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1147.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1148.     start_brace ();
  1149.     genflags(flag_cmp, table68k[opcode].size, "newv", "src", "dst");
  1150.     break;
  1151.      case i_CMPA:
  1152.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1153.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1154.     start_brace ();
  1155.     genflags(flag_cmp, sz_long, "newv", "src", "dst");
  1156.     break;
  1157.     /* The next two are coded a little unconventional, but they are doing
  1158.      * weird things... */
  1159.      case i_MVPRM:
  1160.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1161.     printf("\tuaecptr memp = m68k_areg(regs, dstreg) + %s;\n", gen_nextiword());
  1162.     if (table68k[opcode].size == sz_word) {
  1163.         printf("\tput_byte(memp, src >> 8); put_byte(memp + 2, src);\n");
  1164.     } else {
  1165.         printf("\tput_byte(memp, src >> 24); put_byte(memp + 2, src >> 16);\n");
  1166.         printf("\tput_byte(memp + 4, src >> 8); put_byte(memp + 6, src);\n");
  1167.     }
  1168.     break;
  1169.      case i_MVPMR:
  1170.     printf("\tuaecptr memp = m68k_areg(regs, srcreg) + %s;\n", gen_nextiword());
  1171.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  1172.     if (table68k[opcode].size == sz_word) {
  1173.         printf("\tuae_u16 val = (get_byte(memp) << 8) + get_byte(memp + 2);\n");
  1174.     } else {
  1175.         printf("\tuae_u32 val = (get_byte(memp) << 24) + (get_byte(memp + 2) << 16)\n");
  1176.         printf("              + (get_byte(memp + 4) << 8) + get_byte(memp + 6);\n");
  1177.     }
  1178.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1179.     break;
  1180.      case i_MOVE:
  1181.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1182.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  1183.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  1184.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1185.     break;
  1186.      case i_MOVEA:
  1187.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1188.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  1189.     if (table68k[opcode].size == sz_word) {
  1190.         printf("\tuae_u32 val = (uae_s32)(uae_s16)src;\n");
  1191.     } else {
  1192.         printf("\tuae_u32 val = src;\n");
  1193.     }
  1194.     genastore("val", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1195.     break;
  1196.      case i_MVSR2:
  1197.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 2, 0);
  1198.     printf("\tMakeSR();\n");
  1199.     if (table68k[opcode].size == sz_byte)
  1200.         genastore("regs.sr & 0xff", table68k[opcode].smode, "srcreg", sz_word, "src");
  1201.     else
  1202.         genastore("regs.sr", table68k[opcode].smode, "srcreg", sz_word, "src");
  1203.     break;
  1204.      case i_MV2SR:
  1205.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1206.     if (table68k[opcode].size == sz_byte)
  1207.         printf("\tMakeSR();\n\tregs.sr &= 0xFF00;\n\tregs.sr |= src & 0xFF;\n");
  1208.     else {
  1209.         printf("\tregs.sr = src;\n");
  1210.     }
  1211.     printf("\tMakeFromSR();\n");
  1212.     break;
  1213.      case i_SWAP:
  1214.     genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
  1215.     start_brace ();
  1216.     printf("\tuae_u32 dst = ((src >> 16)&0xFFFF) | ((src&0xFFFF)<<16);\n");
  1217.     genflags(flag_logical, sz_long, "dst", "", "");
  1218.     genastore("dst",table68k[opcode].smode, "srcreg", sz_long, "src");
  1219.     break;
  1220.      case i_EXG:
  1221.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1222.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1223.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1224.     genastore("src",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1225.     break;
  1226.      case i_EXT:
  1227.     genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
  1228.     start_brace ();
  1229.     switch(table68k[opcode].size) {
  1230.      case sz_byte: printf("\tuae_u32 dst = (uae_s32)(uae_s8)src;\n"); break;
  1231.      case sz_word: printf("\tuae_u16 dst = (uae_s16)(uae_s8)src;\n"); break;
  1232.      case sz_long: printf("\tuae_u32 dst = (uae_s32)(uae_s16)src;\n"); break;
  1233.      default: abort();
  1234.     }
  1235.     genflags(flag_logical,
  1236.          table68k[opcode].size == sz_word ? sz_word : sz_long, "dst", "", "");
  1237.     genastore("dst",table68k[opcode].smode, "srcreg",
  1238.           table68k[opcode].size == sz_word ? sz_word : sz_long, "src");
  1239.     break;
  1240.      case i_MVMEL:
  1241.     genmovemel(opcode);
  1242.     break;
  1243.      case i_MVMLE:
  1244.     genmovemle(opcode);
  1245.     break;
  1246.      case i_TRAP:
  1247.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1248.     sync_m68k_pc();
  1249.     printf("\tException(src+32,0);\n");
  1250.     m68k_pc_offset = 0;
  1251.     break;
  1252.      case i_MVR2USP:
  1253.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1254.     printf("\tregs.usp = src;\n");
  1255.     break;
  1256.      case i_MVUSP2R:
  1257.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 2, 0);
  1258.     genastore("regs.usp", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1259.     break;
  1260.      case i_RESET:
  1261.     printf("\tcustomreset();\n");
  1262.     break;
  1263.      case i_NOP:
  1264.     break;
  1265.      case i_STOP:
  1266.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1267.     printf("\tregs.sr = src;\n");
  1268.     printf("\tMakeFromSR();\n");
  1269.     printf("\tm68k_setstopped(1);\n");
  1270.     break;
  1271.      case i_RTE:
  1272.     if (CPU_LEVEL == 0) {
  1273.         genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1274.         genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1275.         printf("\tregs.sr = sr; m68k_setpc_rte(pc);\n");
  1276.         printf("\tMakeFromSR();\n");
  1277.     } else {
  1278.         int old_brace_level = n_braces;
  1279.         printf("\tuae_u16 newsr; uae_u32 newpc; for (;;) {\n");
  1280.         genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1281.         genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1282.         genamode(Aipi, "7", sz_word, "format", 1, 0);
  1283.         printf("\tnewsr = sr; newpc = pc;\n");
  1284.         printf("\tif ((format & 0xF000) == 0x0000) { break; }\n");
  1285.         printf("\telse if ((format & 0xF000) == 0x1000) { ; }\n");
  1286.         printf("\telse if ((format & 0xF000) == 0x2000) { m68k_areg(regs, 7) += 4; break; }\n");
  1287.         printf("\telse if ((format & 0xF000) == 0x8000) { m68k_areg(regs, 7) += 50; break; }\n");
  1288.         printf("\telse if ((format & 0xF000) == 0x9000) { m68k_areg(regs, 7) += 12; break; }\n");
  1289.         printf("\telse if ((format & 0xF000) == 0xa000) { m68k_areg(regs, 7) += 24; break; }\n");
  1290.         printf("\telse if ((format & 0xF000) == 0xb000) { m68k_areg(regs, 7) += 84; break; }\n");
  1291.         printf("\telse { Exception(14,0); goto %s; }\n", endlabelstr);
  1292.         printf("\tregs.sr = newsr; MakeFromSR();\n}\n");
  1293.         pop_braces (old_brace_level);
  1294.         printf("\tregs.sr = newsr; MakeFromSR();\n");
  1295.         printf("\tm68k_setpc_rte(newpc);\n");
  1296.     }
  1297.     /* PC is set and prefetch filled. */
  1298.     m68k_pc_offset = 0;
  1299.     break;
  1300.      case i_RTD:
  1301.     printf("\tcompiler_flush_jsr_stack();\n");
  1302.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1303.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "offs", 1, 0);
  1304.     printf("\tm68k_areg(regs, 7) += offs;\n");
  1305.     printf("\tm68k_setpc_rte(pc);\n");
  1306.     /* PC is set and prefetch filled. */
  1307.     m68k_pc_offset = 0;
  1308.     break;
  1309.      case i_LINK:
  1310.     genamode(Apdi, "7", sz_long, "old", 2, 0);
  1311.     genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
  1312.     genastore("src", Apdi, "7", sz_long, "old");
  1313.     genastore("m68k_areg(regs, 7)", table68k[opcode].smode, "srcreg", sz_long, "src");
  1314.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1315.     printf("\tm68k_areg(regs, 7) += offs;\n");
  1316.     break;
  1317.      case i_UNLK:
  1318.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1319.     printf("\tm68k_areg(regs, 7) = src;\n");
  1320.     genamode(Aipi, "7", sz_long, "old", 1, 0);
  1321.     genastore("old", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1322.     break;
  1323.      case i_RTS:
  1324.     printf("\tm68k_do_rts();\n");
  1325.     /* PC is set and prefetch filled. */
  1326.     m68k_pc_offset = 0;
  1327.     break;
  1328.      case i_TRAPV:
  1329.     sync_m68k_pc ();
  1330.     printf("\tif(VFLG) { Exception(7,m68k_getpc()); goto %s; }\n", endlabelstr);
  1331.     break;
  1332.      case i_RTR:
  1333.     printf("\tcompiler_flush_jsr_stack();\n");
  1334.     printf("\tMakeSR();\n");
  1335.     genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1336.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1337.     printf("\tregs.sr &= 0xFF00; sr &= 0xFF;\n");
  1338.     printf("\tregs.sr |= sr; m68k_setpc(pc);\n");
  1339.     printf("\tMakeFromSR();\n");
  1340.     m68k_pc_offset = 0;
  1341.     break;
  1342.      case i_JSR:
  1343.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1344.     printf("\tm68k_do_jsr(m68k_getpc() + %d, srca);\n", m68k_pc_offset);
  1345.     m68k_pc_offset = 0;
  1346.     break;
  1347.      case i_JMP:
  1348.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1349.     printf("\tm68k_setpc(srca);\n");
  1350.     m68k_pc_offset = 0;
  1351.     break;
  1352.      case i_BSR:
  1353.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1354.     printf("\tuae_s32 s = (uae_s32)src + 2;\n");
  1355. #ifndef NO_EXCEPTION_3
  1356.     printf("\tif (src & 1) {\n");
  1357.     printf("\tlast_addr_for_exception_3 = m68k_getpc() + 2;\n");
  1358.     printf("\t\tlast_fault_for_exception_3 = m68k_getpc() + s;\n");
  1359.     printf("\t\tlast_op_for_exception_3 = opcode; Exception(3,0); goto %s;\n", endlabelstr);
  1360.     printf("\t}\n");
  1361. #endif
  1362.     printf("\tm68k_do_bsr(m68k_getpc() + %d, s);\n", m68k_pc_offset);
  1363.     printf("\tfill_prefetch_0();\n");
  1364.     m68k_pc_offset = 0;
  1365.     break;
  1366.      case i_Bcc:
  1367. #if CPU_LEVEL < 2
  1368.     if (table68k[opcode].size == sz_long) {
  1369.         printf("\tm68k_incpc(2);\n");
  1370.         printf("\tif (!cctrue(%d)) goto %s;\n", table68k[opcode].cc, endlabelstr);
  1371.         printf("\t\tlast_addr_for_exception_3 = m68k_getpc() + 2;\n");
  1372.         printf("\t\tlast_fault_for_exception_3 = m68k_getpc() + 1;\n");
  1373.         printf("\t\tlast_op_for_exception_3 = opcode; Exception(3,0); goto %s;\n", endlabelstr);
  1374.     }
  1375. #endif
  1376.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1377.     printf("\tif (!cctrue(%d)) goto didnt_jump;\n", table68k[opcode].cc);
  1378. #ifndef NO_EXCEPTION_3
  1379.     printf("\tif (src & 1) {\n");
  1380.     printf("\t\tlast_addr_for_exception_3 = m68k_getpc() + 2;\n");
  1381.     printf("\t\tlast_fault_for_exception_3 = m68k_getpc() + 2 + (uae_s32)src;\n");
  1382.     printf("\t\tlast_op_for_exception_3 = opcode; Exception(3,0); goto %s;\n", endlabelstr);
  1383.     printf("\t}\n");
  1384. #endif
  1385. #ifdef USE_COMPILER
  1386.     printf("\tm68k_setpc_bcc(m68k_getpc() + 2 + (uae_s32)src);\n");
  1387. #else
  1388.     printf("\tm68k_incpc ((uae_s32)src + 2);\n");
  1389. #endif
  1390.     printf("\tfill_prefetch_0();\n");
  1391.     printf("\tgoto %s;\n", endlabelstr);
  1392.     printf("didnt_jump:;\n");
  1393.     break;
  1394.      case i_LEA:
  1395.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1396.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  1397.     genastore("srca", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1398.     break;
  1399.      case i_PEA:
  1400.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1401.     genamode(Apdi, "7", sz_long, "dst", 2, 0);
  1402.     genastore("srca", Apdi, "7", sz_long, "dst");
  1403.     break;
  1404.      case i_DBcc:
  1405.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1406.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1407.  
  1408.     printf("\tif (!cctrue(%d)) {\n", table68k[opcode].cc);
  1409.     genastore("(src-1)", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1410.  
  1411.     printf("\t\tif (src) {\n");
  1412. #ifndef NO_EXCEPTION_3
  1413.     printf("\t\t\tif (offs & 1) {\n");
  1414.     printf("\t\t\tlast_addr_for_exception_3 = m68k_getpc() + 2;\n");
  1415.     printf("\t\t\tlast_fault_for_exception_3 = m68k_getpc() + 2 + (uae_s32)offs + 2;\n");
  1416.     printf("\t\t\tlast_op_for_exception_3 = opcode; Exception(3,0); goto %s;\n", endlabelstr);
  1417.     printf("\t\t}\n");
  1418. #endif
  1419. #ifdef USE_COMPILER
  1420.     printf("\t\t\tm68k_setpc_bcc(m68k_getpc() + (uae_s32)offs + 2);\n");
  1421. #else
  1422.     printf("\t\t\tm68k_incpc((uae_s32)offs + 2);\n");
  1423. #endif
  1424.     printf("\t\t\tfill_prefetch_0();\n");
  1425.     printf("\t\tgoto %s;\n", endlabelstr);
  1426.     printf("\t\t}\n");
  1427.     printf("\t}\n");
  1428.     break;
  1429.      case i_Scc:
  1430.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 2, 0);
  1431.     start_brace ();
  1432.     printf("\tint val = cctrue(%d) ? 0xff : 0;\n", table68k[opcode].cc);
  1433.     genastore("val",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1434.     break;
  1435.      case i_DIVU:
  1436.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  1437.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1438.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1439.     printf("\tif(src == 0) { Exception(5,oldpc); goto %s; } else {\n", endlabelstr);
  1440.     printf("\tuae_u32 newv = (uae_u32)dst / (uae_u32)(uae_u16)src;\n");
  1441.     printf("\tuae_u32 rem = (uae_u32)dst %% (uae_u32)(uae_u16)src;\n");
  1442.     /* The N flag appears to be set each time there is an overflow.
  1443.      * Weird. */
  1444.     printf("\tif (newv > 0xffff) { VFLG = NFLG = 1; CFLG = 0; } else\n\t{\n");
  1445.     genflags(flag_logical, sz_word, "newv", "", "");
  1446.     printf("\tnewv = (newv & 0xffff) | ((uae_u32)rem << 16);\n");
  1447.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1448.     printf("\t}\n");
  1449.     printf("\t}\n");
  1450.     break;
  1451.      case i_DIVS:
  1452.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  1453.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1454.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1455.     printf("\tif(src == 0) { Exception(5,oldpc); goto %s; } else {\n", endlabelstr);
  1456.     printf("\tuae_s32 newv = (uae_s32)dst / (uae_s32)(uae_s16)src;\n");
  1457.     printf("\tuae_u16 rem = (uae_s32)dst %% (uae_s32)(uae_s16)src;\n");
  1458.     printf("\tif ((newv & 0xffff8000) != 0 && (newv & 0xffff8000) != 0xffff8000) { VFLG = NFLG = 1; CFLG = 0; } else\n\t{\n");
  1459.     printf("\tif (((uae_s16)rem < 0) != ((uae_s32)dst < 0)) rem = -rem;\n");
  1460.     genflags(flag_logical, sz_word, "newv", "", "");
  1461.     printf("\tnewv = (newv & 0xffff) | ((uae_u32)rem << 16);\n");
  1462.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1463.     printf("\t}\n");
  1464.     printf("\t}\n");
  1465.     break;
  1466.      case i_MULU:
  1467.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1468.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1469.     start_brace ();
  1470.     printf("\tuae_u32 newv = (uae_u32)(uae_u16)dst * (uae_u32)(uae_u16)src;\n");
  1471.     genflags(flag_logical, sz_long, "newv", "", "");
  1472.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1473. #ifdef WANT_SLOW_MULTIPLY
  1474.     printf("\tregs.spcflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1475. #endif
  1476.     break;
  1477.      case i_MULS:
  1478.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1479.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1480.     start_brace ();
  1481.     printf("\tuae_u32 newv = (uae_s32)(uae_s16)dst * (uae_s32)(uae_s16)src;\n");
  1482.     genflags(flag_logical, sz_long, "newv", "", "");
  1483.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1484. #ifdef WANT_SLOW_MULTIPLY
  1485.     printf("\tregs.spcflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1486. #endif
  1487.     break;
  1488.      case i_CHK:
  1489.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  1490.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1491.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1492.     printf("\tif ((uae_s32)dst < 0) { NFLG=1; Exception(6,oldpc); goto %s; }\n", endlabelstr);
  1493.     printf("\telse if (dst > src) { NFLG=0; Exception(6,oldpc); goto %s; }\n", endlabelstr);
  1494.     break;
  1495.  
  1496.      case i_CHK2:
  1497.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  1498.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1499.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  1500.     printf("\t{uae_s32 upper,lower,reg = regs.regs[(extra >> 12) & 15];\n");
  1501.     switch (table68k[opcode].size) {
  1502.      case sz_byte:
  1503.         printf("\tlower=(uae_s32)(uae_s8)get_byte(dsta); upper = (uae_s32)(uae_s8)get_byte(dsta+1);\n");
  1504.         printf("\tif ((extra & 0x8000) == 0) reg = (uae_s32)(uae_s8)reg;\n");
  1505.         break;
  1506.      case sz_word:
  1507.         printf("\tlower=(uae_s32)(uae_s16)get_word(dsta); upper = (uae_s32)(uae_s16)get_word(dsta+2);\n");
  1508.         printf("\tif ((extra & 0x8000) == 0) reg = (uae_s32)(uae_s16)reg;\n");
  1509.         break;
  1510.      case sz_long:
  1511.         printf("\tlower=get_long(dsta); upper = get_long(dsta+4);\n");
  1512.         break;
  1513.      default:
  1514.         abort();
  1515.     }
  1516.     printf("\tZFLG=upper == reg || lower == reg;\n");
  1517.     printf("\tCFLG=lower <= upper ? reg < lower || reg > upper : reg > upper || reg < lower;\n");
  1518.     printf("\tif ((extra & 0x800) && CFLG) { Exception(6,oldpc); goto %s; }\n}\n", endlabelstr);
  1519.     break;
  1520.  
  1521.      case i_ASR:
  1522.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1523.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1524.     start_brace ();
  1525.     switch(table68k[opcode].size) {
  1526.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1527.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1528.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1529.      default: abort();
  1530.     }
  1531.     switch(table68k[opcode].size) {
  1532.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1533.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1534.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1535.      default: abort();
  1536.     }
  1537.     printf("\tuae_u32 sign = cmask & val;\n");
  1538.     printf("\tcnt &= 63;\n");
  1539.     printf("\tVFLG = 0;\n");
  1540.     printf("\tif (!cnt) { CFLG = 0; } else {\n");
  1541.     printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
  1542.     printf("\t\tval = sign ? %s : 0;\n",bit_mask(table68k[opcode].size));
  1543.     printf("\t\tCFLG=XFLG= sign ? 1 : 0;\n");
  1544.     printf("\t} else {\n");
  1545.     printf("\t\tCFLG=XFLG=(val >> (cnt-1)) & 1;\n");
  1546.     printf("\t\tval >>= cnt;\n");
  1547.     printf("\t\tif (sign) val |= %s << (%d - cnt);\n",
  1548.            bit_mask(table68k[opcode].size),
  1549.            bit_size(table68k[opcode].size));
  1550.     printf("\t}}\n");
  1551.     printf("\tNFLG = sign != 0;\n");
  1552.     printf("\tZFLG = val == 0;\n");
  1553.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1554.     break;
  1555.      case i_ASL:
  1556.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1557.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1558.     start_brace ();
  1559.     switch(table68k[opcode].size) {
  1560.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1561.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1562.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1563.      default: abort();
  1564.     }
  1565.     switch(table68k[opcode].size) {
  1566.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1567.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1568.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1569.      default: abort();
  1570.     }
  1571.     printf("\tcnt &= 63;\n");
  1572.     printf("\tVFLG = 0;\n");
  1573.     printf("\tif (!cnt) { CFLG = 0; } else {\n");
  1574.     printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
  1575.     printf("\t\tVFLG = val != 0;\n");
  1576.     printf("\t\tCFLG=XFLG = cnt == %d ? val & 1 : 0;\n",
  1577.                     bit_size(table68k[opcode].size));
  1578.     printf("\t\tval = 0;\n");
  1579.     printf("\t} else {\n");
  1580.     printf("\t\tuae_u32 mask = (%s << (%d - cnt)) & %s;\n",
  1581.            bit_mask(table68k[opcode].size),
  1582.            bit_size(table68k[opcode].size)-1,
  1583.            bit_mask(table68k[opcode].size));
  1584.     printf("\t\tCFLG=XFLG=(val << (cnt-1)) & cmask ? 1 : 0;\n");
  1585.     printf("\t\tVFLG = (val & mask) != mask && (val & mask) != 0;\n");
  1586.     printf("\t\tval <<= cnt;\n");
  1587.     printf("\t}}\n");
  1588.     printf("\tNFLG = (val&cmask) != 0;\n");
  1589.     printf("\tZFLG = val == 0;\n");
  1590.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1591.     break;
  1592.      case i_LSR:
  1593.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1594.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1595.     start_brace ();
  1596.     switch(table68k[opcode].size) {
  1597.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1598.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1599.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1600.      default: abort();
  1601.     }
  1602.     switch(table68k[opcode].size) {
  1603.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1604.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1605.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1606.      default: abort();
  1607.     }
  1608.     printf("\tcnt &= 63;\n");
  1609.     printf("\tif (!cnt) { CFLG = 0; } else {\n");
  1610.     printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
  1611.     printf("\t\tCFLG=XFLG = cnt == %d ? (val & cmask ? 1 : 0) : 0;\n",
  1612.            bit_size(table68k[opcode].size));
  1613.     printf("\t\tval = 0;\n");
  1614.     printf("\t} else {\n");
  1615.     printf("\t\tCFLG=XFLG=(val >> (cnt-1)) & 1;\n");
  1616.     printf("\t\tval >>= cnt;\n");
  1617.     printf("\t}}\n");
  1618.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1619.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1620.     break;
  1621.      case i_LSL:
  1622.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1623.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1624.     start_brace ();
  1625.     switch(table68k[opcode].size) {
  1626.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1627.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1628.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1629.      default: abort();
  1630.     }
  1631.     switch(table68k[opcode].size) {
  1632.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1633.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1634.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1635.      default: abort();
  1636.     }
  1637.     printf("\tcnt &= 63;\n");
  1638.     printf("\tif (!cnt) { CFLG = 0; } else {\n");
  1639.     printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
  1640.     printf("\t\tCFLG=XFLG = cnt == %d ? val & 1 : 0;\n",
  1641.            bit_size(table68k[opcode].size));
  1642.     printf("\t\tval = 0;\n");
  1643.     printf("\t} else {\n");
  1644.     printf("\t\tCFLG=XFLG=(val << (cnt-1)) & cmask ? 1 : 0;\n");
  1645.     printf("\t\tval <<= cnt;\n");
  1646.     printf("\t}}\n");
  1647.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1648.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1649.     break;
  1650.      case i_ROL:
  1651.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1652.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1653.     start_brace ();
  1654.     switch(table68k[opcode].size) {
  1655.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1656.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1657.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1658.      default: abort();
  1659.     }
  1660.     switch(table68k[opcode].size) {
  1661.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1662.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1663.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1664.      default: abort();
  1665.     }
  1666.     printf("\tcnt &= 63;\n");
  1667.     printf("\tif (!cnt) { CFLG = 0; } else {\n");
  1668.     printf("\tuae_u32 carry;\n");
  1669.     printf("\tfor(;cnt;--cnt){\n");
  1670.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1671.     printf("\tif(carry) val |= 1;\n");
  1672.     printf("\t}\n");
  1673.     printf("\tCFLG = carry!=0;\n}\n");
  1674.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1675.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1676.     break;
  1677.      case i_ROR:
  1678.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1679.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1680.     start_brace ();
  1681.     switch(table68k[opcode].size) {
  1682.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1683.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1684.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1685.      default: abort();
  1686.     }
  1687.     switch(table68k[opcode].size) {
  1688.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1689.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1690.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1691.      default: abort();
  1692.     }
  1693.     printf("\tcnt &= 63;\n");
  1694.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1695.     printf("\tuae_u32 carry;\n");
  1696.     printf("\tfor(;cnt;--cnt){\n");
  1697.     printf("\tcarry=val&1; val = val >> 1;\n");
  1698.     printf("\tif(carry) val |= cmask;\n");
  1699.     printf("\t}\n");
  1700.     printf("\tCFLG = carry;\n}\n");
  1701.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1702.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1703.     break;
  1704.      case i_ROXL:
  1705.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1706.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1707.     start_brace ();
  1708.     switch(table68k[opcode].size) {
  1709.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1710.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1711.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1712.      default: abort();
  1713.     }
  1714.     switch(table68k[opcode].size) {
  1715.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1716.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1717.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1718.      default: abort();
  1719.     }
  1720.     printf("\tuae_u32 carry;\n");
  1721.     printf("\tcnt &= 63;\n");
  1722.     printf("\tfor(;cnt;--cnt){\n");
  1723.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1724.     printf("\tif(XFLG) val |= 1;\n");
  1725.     printf("\tXFLG = carry != 0;\n");
  1726.     printf("\t}\n");
  1727.     printf("\tCFLG = XFLG;\n");
  1728.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1729.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1730.     break;
  1731.      case i_ROXR:
  1732.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1733.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1734.     start_brace ();
  1735.     switch(table68k[opcode].size) {
  1736.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1737.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1738.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1739.      default: abort();
  1740.     }
  1741.     switch(table68k[opcode].size) {
  1742.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1743.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1744.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1745.      default: abort();
  1746.     }
  1747.     printf("\tuae_u32 carry;\n");
  1748.     printf("\tcnt &= 63;\n");
  1749.     printf("\tfor(;cnt;--cnt){\n");
  1750.     printf("\tcarry=val&1; val >>= 1;\n");
  1751.     printf("\tif(XFLG) val |= cmask;\n");
  1752.     printf("\tXFLG = carry;\n");
  1753.     printf("\t}\n");
  1754.     printf("\tCFLG = XFLG;\n");
  1755.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1756.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1757.     break;
  1758.      case i_ASRW:
  1759.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1760.     printf("\tVFLG = 0;\n");
  1761.     start_brace ();
  1762.     switch(table68k[opcode].size) {
  1763.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1764.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1765.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1766.      default: abort();
  1767.     }
  1768.     switch(table68k[opcode].size) {
  1769.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1770.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1771.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1772.      default: abort();
  1773.     }
  1774.     printf("\tuae_u32 sign = cmask & val;\n");
  1775.     printf("\tCFLG=XFLG=val&1; val = (val >> 1) | sign;\n");
  1776.     printf("\tNFLG = sign != 0;\n");
  1777.     printf("\tZFLG = val == 0;\n");
  1778.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1779.     break;
  1780.      case i_ASLW:
  1781.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1782.     printf("\tVFLG = 0;\n");
  1783.     start_brace ();
  1784.     switch(table68k[opcode].size) {
  1785.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1786.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1787.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1788.      default: abort();
  1789.     }
  1790.     switch(table68k[opcode].size) {
  1791.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1792.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1793.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1794.      default: abort();
  1795.     }
  1796.     printf("\tuae_u32 sign = cmask & val;\n");
  1797.     printf("\tCFLG=XFLG=(val&cmask)!=0; val <<= 1;\n");
  1798.     printf("\tif ((val&cmask)!=sign) VFLG=1;\n");
  1799.     printf("\tNFLG = (val&cmask) != 0;\n");
  1800.     printf("\tZFLG = val == 0;\n");
  1801.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1802.     break;
  1803.      case i_LSRW:
  1804.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1805.     start_brace ();
  1806.     switch(table68k[opcode].size) {
  1807.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1808.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1809.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1810.      default: abort();
  1811.     }
  1812.     printf("\tuae_u32 carry = val&1;\n");
  1813.     printf("\tval >>= 1;\n");
  1814.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1815.     printf("CFLG = XFLG = carry!=0;\n");
  1816.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1817.     break;
  1818.      case i_LSLW:
  1819.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1820.     start_brace ();
  1821.     switch(table68k[opcode].size) {
  1822.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1823.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1824.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1825.      default: abort();
  1826.     }
  1827.     switch(table68k[opcode].size) {
  1828.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1829.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1830.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1831.      default: abort();
  1832.     }
  1833.     printf("\tuae_u32 carry = val&cmask;\n");
  1834.     printf("\tval <<= 1;\n");
  1835.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1836.     printf("CFLG = XFLG = carry!=0;\n");
  1837.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1838.     break;
  1839.      case i_ROLW:
  1840.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1841.     start_brace ();
  1842.     switch(table68k[opcode].size) {
  1843.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1844.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1845.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1846.      default: abort();
  1847.     }
  1848.     switch(table68k[opcode].size) {
  1849.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1850.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1851.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1852.      default: abort();
  1853.     }
  1854.     printf("\tuae_u32 carry = val&cmask;\n");
  1855.     printf("\tval <<= 1;\n");
  1856.     printf("\tif(carry)  val |= 1;\n");
  1857.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1858.     printf("CFLG = carry!=0;\n");
  1859.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1860.     break;
  1861.      case i_RORW:
  1862.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1863.     start_brace ();
  1864.     switch(table68k[opcode].size) {
  1865.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1866.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1867.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1868.      default: abort();
  1869.     }
  1870.     printf("\tuae_u32 carry = val&1;\n");
  1871.     switch(table68k[opcode].size) {
  1872.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1873.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1874.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1875.      default: abort();
  1876.     }
  1877.     printf("\tval >>= 1;\n");
  1878.     printf("\tif(carry) val |= cmask;\n");
  1879.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1880.     printf("CFLG = carry!=0;\n");
  1881.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1882.     break;
  1883.      case i_ROXLW:
  1884.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1885.     start_brace ();
  1886.     switch(table68k[opcode].size) {
  1887.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1888.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1889.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1890.      default: abort();
  1891.     }
  1892.     switch(table68k[opcode].size) {
  1893.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1894.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1895.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1896.      default: abort();
  1897.     }
  1898.     printf("\tuae_u32 carry = val&cmask;\n");
  1899.     printf("\tval <<= 1;\n");
  1900.     printf("\tif(XFLG) val |= 1;\n");
  1901.     printf("\tXFLG = carry != 0;\n");
  1902.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1903.     printf("XFLG = CFLG = carry!=0;\n");
  1904.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1905.     break;
  1906.      case i_ROXRW:
  1907.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1908.     start_brace ();
  1909.     switch(table68k[opcode].size) {
  1910.      case sz_byte: printf("\tuae_u8 val = data;\n"); break;
  1911.      case sz_word: printf("\tuae_u16 val = data;\n"); break;
  1912.      case sz_long: printf("\tuae_u32 val = data;\n"); break;
  1913.      default: abort();
  1914.     }
  1915.     printf("\tuae_u32 carry = val&1;\n");
  1916.     switch(table68k[opcode].size) {
  1917.      case sz_byte: printf("\tuae_u32 cmask = 0x80;\n"); break;
  1918.      case sz_word: printf("\tuae_u32 cmask = 0x8000;\n"); break;
  1919.      case sz_long: printf("\tuae_u32 cmask = 0x80000000;\n"); break;
  1920.      default: abort();
  1921.     }
  1922.     printf("\tval >>= 1;\n");
  1923.     printf("\tif(XFLG) val |= cmask;\n");
  1924.     printf("\tXFLG = carry != 0;\n");
  1925.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1926.     printf("XFLG = CFLG = carry!=0;\n");
  1927.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1928.     break;
  1929.      case i_MOVEC2:
  1930.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1931.     start_brace();
  1932.     printf("\tint regno = (src >> 12) & 15;\n");
  1933.     printf("\tuae_u32 *regp = regs.regs + regno;\n");
  1934.     printf("\tm68k_movec2(src & 0xFFF, regp);\n");
  1935.     break;
  1936.      case i_MOVE2C:
  1937.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1938.     start_brace();
  1939.     printf("\tint regno = (src >> 12) & 15;\n");
  1940.     printf("\tuae_u32 *regp = regs.regs + regno;\n");
  1941.     printf("\tm68k_move2c(src & 0xFFF, regp);\n");
  1942.     break;
  1943.      case i_CAS:
  1944.     {
  1945.         int old_brace_level;
  1946.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1947.         genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1948.         start_brace();
  1949.         printf("\tint ru = (src >> 6) & 7;\n");
  1950.         printf("\tint rc = src & 7;\n");
  1951.         genflags(flag_cmp, table68k[opcode].size, "newv", "m68k_dreg(regs, rc)", "dst");
  1952.         printf("\tif (ZFLG)");
  1953.         old_brace_level = n_braces;
  1954.         start_brace ();
  1955.         genastore("(m68k_dreg(regs, ru))",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1956.         pop_braces (old_brace_level);
  1957.         printf("else");
  1958.         start_brace ();
  1959.         printf("m68k_dreg(regs, rc) = dst;\n");
  1960.         pop_braces (old_brace_level);
  1961.     }
  1962.     break;
  1963.      case i_CAS2:
  1964.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1965.     printf("\tuae_u32 rn1 = regs.regs[(extra >> 28) & 7];\n");
  1966.     printf("\tuae_u32 rn2 = regs.regs[(extra >> 12) & 7];\n");
  1967.     if (table68k[opcode].size == sz_word) {
  1968.          int old_brace_level = n_braces;
  1969.          printf("\tuae_u16 dst1 = get_word(rn1), dst2 = get_word(rn2);\n");
  1970.          genflags(flag_cmp, table68k[opcode].size, "newv", "m68k_dreg(regs, (extra >> 16) & 7)", "dst1");
  1971.          printf("\tif (ZFLG) {\n");
  1972.          genflags(flag_cmp, table68k[opcode].size, "newv", "m68k_dreg(regs, extra & 7)", "dst2");
  1973.          printf("\tif (ZFLG) {\n");
  1974.          printf("\tput_word(rn1, m68k_dreg(regs, (extra >> 22) & 7));\n");
  1975.          printf("\tput_word(rn1, m68k_dreg(regs, (extra >> 6) & 7));\n");
  1976.          printf("\t}}\n");
  1977.          pop_braces (old_brace_level);
  1978.          printf("\tif (!ZFLG) {\n");
  1979.          printf("\tm68k_dreg(regs, (extra >> 22) & 7) = (m68k_dreg(regs, (extra >> 22) & 7) & ~0xffff) | (dst1 & 0xffff);\n");
  1980.          printf("\tm68k_dreg(regs, (extra >> 6) & 7) = (m68k_dreg(regs, (extra >> 6) & 7) & ~0xffff) | (dst2 & 0xffff);\n");
  1981.          printf("\t}\n");
  1982.     } else {
  1983.          int old_brace_level = n_braces;
  1984.          printf("\tuae_u32 dst1 = get_long(rn1), dst2 = get_long(rn2);\n");
  1985.          genflags(flag_cmp, table68k[opcode].size, "newv", "m68k_dreg(regs, (extra >> 16) & 7)", "dst1");
  1986.          printf("\tif (ZFLG) {\n");
  1987.          genflags(flag_cmp, table68k[opcode].size, "newv", "m68k_dreg(regs, extra & 7)", "dst2");
  1988.          printf("\tif (ZFLG) {\n");
  1989.          printf("\tput_long(rn1, m68k_dreg(regs, (extra >> 22) & 7));\n");
  1990.          printf("\tput_long(rn1, m68k_dreg(regs, (extra >> 6) & 7));\n");
  1991.          printf("\t}}\n");
  1992.          pop_braces (old_brace_level);
  1993.          printf("\tif (!ZFLG) {\n");
  1994.          printf("\tm68k_dreg(regs, (extra >> 22) & 7) = dst1;\n");
  1995.          printf("\tm68k_dreg(regs, (extra >> 6) & 7) = dst2;\n");
  1996.          printf("\t}\n");
  1997.     }
  1998.     break;
  1999.      case i_MOVES:    /* ignore DFC and SFC because we have no MMU */
  2000.     {
  2001.         int old_brace_level;
  2002.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2003.         printf("\tif (extra & 0x800)\n");
  2004.         old_brace_level = n_braces;
  2005.         start_brace ();
  2006.         printf("\tuae_u32 src = regs.regs[(extra >> 12) & 15];\n");
  2007.         genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 2, 0);
  2008.         genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  2009.         pop_braces (old_brace_level);
  2010.         printf("else");
  2011.         start_brace ();
  2012.         genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 1, 0);
  2013.         printf("\tif (extra & 0x8000) {\n");
  2014.         switch(table68k[opcode].size) {
  2015.          case sz_byte: printf("\tm68k_areg(regs, (extra >> 12) & 7) = (uae_s32)(uae_s8)src;\n"); break;
  2016.          case sz_word: printf("\tm68k_areg(regs, (extra >> 12) & 7) = (uae_s32)(uae_s16)src;\n"); break;
  2017.          case sz_long: printf("\tm68k_areg(regs, (extra >> 12) & 7) = src;\n"); break;
  2018.          default: abort();
  2019.         }
  2020.         printf("\t} else {\n");
  2021.         genastore("src", Dreg, "(extra >> 12) & 7", table68k[opcode].size, "");
  2022.         printf("\t}\n");
  2023.         pop_braces (old_brace_level);
  2024.     }
  2025.     break;
  2026.      case i_BKPT:    /* only needed for hardware emulators */
  2027.     sync_m68k_pc();
  2028.     printf("\top_illg(opcode);\n");
  2029.     break;
  2030.      case i_CALLM:    /* not present in 68030 */
  2031.     sync_m68k_pc();
  2032.     printf("\top_illg(opcode);\n");
  2033.     break;
  2034.      case i_RTM:    /* not present in 68030 */
  2035.     sync_m68k_pc();
  2036.     printf("\top_illg(opcode);\n");
  2037.     break;
  2038.      case i_TRAPcc:
  2039.     if (table68k[opcode].smode != am_unknown && table68k[opcode].smode != am_illg)
  2040.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "dummy", 1, 0);
  2041.     printf("\tif (cctrue(%d)) { Exception(7,m68k_getpc()); goto %s; }\n", table68k[opcode].cc, endlabelstr);
  2042.     break;
  2043.      case i_DIVL:
  2044.     sync_m68k_pc ();
  2045.     start_brace ();
  2046.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  2047.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2048.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  2049.     sync_m68k_pc();
  2050.     printf("\tm68k_divl(opcode, dst, extra, oldpc);\n");
  2051.     break;
  2052.      case i_MULL:
  2053.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2054.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  2055.     sync_m68k_pc();
  2056.     printf("\tm68k_mull(opcode, dst, extra);\n");
  2057.     break;
  2058.      case i_BFTST:
  2059.      case i_BFEXTU:
  2060.      case i_BFCHG:
  2061.      case i_BFEXTS:
  2062.      case i_BFCLR:
  2063.      case i_BFFFO:
  2064.      case i_BFSET:
  2065.      case i_BFINS:
  2066.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2067.     genamode (table68k[opcode].dmode, "dstreg", sz_long, "dst", 2, 0);
  2068.     start_brace();
  2069.     printf("\tuae_s32 offset = extra & 0x800 ? m68k_dreg(regs, (extra >> 6) & 7) : (extra >> 6) & 0x1f;\n");
  2070.     printf("\tint width = (((extra & 0x20 ? m68k_dreg(regs, extra & 7) : extra) -1) & 0x1f) +1;\n");
  2071.     if (table68k[opcode].dmode == Dreg) {
  2072.         printf("\tuae_u32 tmp = m68k_dreg(regs, dstreg) << (offset & 0x1f);\n");
  2073.     } else {
  2074.         printf("\tuae_u32 tmp,bf0,bf1;\n");
  2075.         printf("\tdsta += (offset >> 3) | (offset & 0x80000000 ? ~0x1fffffff : 0);\n");
  2076.         printf("\tbf0 = get_long(dsta);bf1 = get_byte(dsta+4) & 0xff;\n");
  2077.         printf("\ttmp = (bf0 << (offset & 7)) | (bf1 >> (8 - (offset & 7)));\n");
  2078.     }
  2079.     printf("\ttmp >>= (32 - width);\n");
  2080.     printf("\tNFLG = tmp & (1 << (width-1)) ? 1 : 0;ZFLG = tmp == 0;VFLG = 0;CFLG = 0;\n");
  2081.     switch(table68k[opcode].mnemo) {
  2082.      case i_BFTST:
  2083.         break;
  2084.      case i_BFEXTU:
  2085.         printf("\tm68k_dreg(regs, (extra >> 12) & 7) = tmp;\n");
  2086.         break;
  2087.      case i_BFCHG:
  2088.         printf("\ttmp = ~tmp;\n");
  2089.         break;
  2090.      case i_BFEXTS:
  2091.         printf("\tif (NFLG) tmp |= width == 32 ? 0 : (-1 << width);\n");
  2092.         printf("\tm68k_dreg(regs, (extra >> 12) & 7) = tmp;\n");
  2093.         break;
  2094.      case i_BFCLR:
  2095.         printf("\ttmp = 0;\n");
  2096.         break;
  2097.      case i_BFFFO:
  2098.         printf("\t{ uae_u32 mask = 1 << (width-1);\n");
  2099.         printf("\twhile (mask) { if (tmp & mask) break; mask >>= 1; offset++; }}\n");
  2100.         printf("\tm68k_dreg(regs, (extra >> 12) & 7) = offset;\n");
  2101.         break;
  2102.      case i_BFSET:
  2103.         printf("\ttmp = 0xffffffff;\n");
  2104.         break;
  2105.      case i_BFINS:
  2106.         printf("\ttmp = m68k_dreg(regs, (extra >> 12) & 7);\n");
  2107.         break;
  2108.      default:
  2109.         break;
  2110.     }
  2111.     if (table68k[opcode].mnemo == i_BFCHG ||
  2112.         table68k[opcode].mnemo == i_BFCLR ||
  2113.         table68k[opcode].mnemo == i_BFSET ||
  2114.         table68k[opcode].mnemo == i_BFINS) {
  2115.         printf("\ttmp <<= (32 - width);\n");
  2116.         if (table68k[opcode].dmode == Dreg) {
  2117.             printf("\tm68k_dreg(regs, dstreg) = (m68k_dreg(regs, dstreg) & ((offset & 0x1f) == 0 ? 0 :\n");
  2118.             printf("\t\t(0xffffffff << (32 - (offset & 0x1f))))) |\n");
  2119.             printf("\t\t(tmp >> (offset & 0x1f)) |\n");
  2120.             printf("\t\t(((offset & 0x1f) + width) >= 32 ? 0 :\n");
  2121.             printf(" (m68k_dreg(regs, dstreg) & ((uae_u32)0xffffffff >> ((offset & 0x1f) + width))));\n");
  2122.         } else {
  2123.             printf("\tbf0 = (bf0 & (0xff000000 << (8 - (offset & 7)))) |\n");
  2124.             printf("\t\t(tmp >> (offset & 7)) |\n");
  2125.             printf("\t\t(((offset & 7) + width) >= 32 ? 0 :\n");
  2126.             printf("\t\t (bf0 & ((uae_u32)0xffffffff >> ((offset & 7) + width))));\n");
  2127.             printf("\tput_long(dsta,bf0 );\n");
  2128.             printf("\tif (((offset & 7) + width) > 32) {\n");
  2129.             printf("\t\tbf1 = (bf1 & (0xff >> (width - 32 + (offset & 7)))) |\n");
  2130.             printf("\t\t\t(tmp << (8 - (offset & 7)));\n");
  2131.             printf("\t\tput_byte(dsta+4,bf1);\n");
  2132.             printf("\t}\n");
  2133.         }
  2134.     }
  2135.     break;
  2136.      case i_PACK:
  2137.     if (table68k[opcode].smode == Dreg) {
  2138.         printf("\tuae_u16 val = m68k_dreg(regs, srcreg) + %s;\n", gen_nextiword());
  2139.         printf("\tm68k_dreg(regs, dstreg) = (m68k_dreg(regs, dstreg) & 0xffffff00) | ((val >> 4) & 0xf0) | (val & 0xf);\n");
  2140.     } else {
  2141.         printf("\tuae_u16 val;\n");
  2142.         printf("\tm68k_areg(regs, srcreg) -= areg_byteinc[srcreg];\n");
  2143.         printf("\tval = (uae_u16)get_byte(m68k_areg(regs, srcreg));\n");
  2144.         printf("\tm68k_areg(regs, srcreg) -= areg_byteinc[srcreg];\n");
  2145.         printf("\tval = (val | ((uae_u16)get_byte(m68k_areg(regs, srcreg)) << 8)) + %s;\n", gen_nextiword());
  2146.         printf("\tm68k_areg(regs, dstreg) -= areg_byteinc[dstreg];\n");
  2147.         printf("\tput_byte(m68k_areg(regs, dstreg),((val >> 4) & 0xf0) | (val & 0xf));\n");
  2148.     }
  2149.     break;
  2150.      case i_UNPK:
  2151.     if (table68k[opcode].smode == Dreg) {
  2152.         printf("\tuae_u16 val = m68k_dreg(regs, srcreg);\n");
  2153.         printf("\tval = (((val << 4) & 0xf00) | (val & 0xf)) + %s;\n", gen_nextiword());
  2154.         printf("\tm68k_dreg(regs, dstreg) = (m68k_dreg(regs, dstreg) & 0xffff0000) | (val & 0xffff);\n");
  2155.     } else {
  2156.         printf("\tuae_u16 val;\n");
  2157.         printf("\tm68k_areg(regs, srcreg) -= areg_byteinc[srcreg];\n");
  2158.         printf("\tval = (uae_u16)get_byte(m68k_areg(regs, srcreg));\n");
  2159.         printf("\tval = (((val << 4) & 0xf00) | (val & 0xf)) + %s;\n", gen_nextiword());
  2160.         printf("\tm68k_areg(regs, dstreg) -= areg_byteinc[dstreg];\n");
  2161.         printf("\tput_byte(m68k_areg(regs, dstreg),val);\n");
  2162.         printf("\tm68k_areg(regs, dstreg) -= areg_byteinc[dstreg];\n");
  2163.         printf("\tput_byte(m68k_areg(regs, dstreg),val >> 8);\n");
  2164.     }
  2165.     break;
  2166.      case i_TAS:
  2167.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  2168.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  2169.     printf("\tsrc |= 0x80;\n");
  2170.     genastore("src", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  2171.     break;
  2172.      case i_FPP:
  2173.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2174.     sync_m68k_pc();
  2175.     printf("\tfpp_opp(opcode,extra);\n");
  2176.     break;
  2177.      case i_FDBcc:
  2178.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2179.     sync_m68k_pc();
  2180.     printf("\tfdbcc_opp(opcode,extra);\n");
  2181.     break;
  2182.      case i_FScc:
  2183.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2184.     sync_m68k_pc();
  2185.     printf("\tfscc_opp(opcode,extra);\n");
  2186.     break;
  2187.      case i_FTRAPcc:
  2188.     sync_m68k_pc();
  2189.     start_brace();
  2190.     printf("\tuaecptr oldpc = m68k_getpc();\n");
  2191.     if (table68k[opcode].smode != am_unknown && table68k[opcode].smode != am_illg)
  2192.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "dummy", 1, 0);
  2193.     sync_m68k_pc();
  2194.     printf("\tftrapcc_opp(opcode,oldpc);\n");
  2195.     break;
  2196.      case i_FBcc:
  2197.     sync_m68k_pc();
  2198.     start_brace();
  2199.     printf("\tuaecptr pc = m68k_getpc();\n");
  2200.     genamode (table68k[opcode].dmode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2201.     sync_m68k_pc();
  2202.     printf("\tfbcc_opp(opcode,pc,extra);\n");
  2203.     break;
  2204.      case i_FSAVE:
  2205.     sync_m68k_pc();
  2206.     printf("\tfsave_opp(opcode);\n");
  2207.     break;
  2208.      case i_FRESTORE:
  2209.     sync_m68k_pc();
  2210.     printf("\tfrestore_opp(opcode);\n");
  2211.     break;
  2212.      case i_MMUOP:
  2213.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  2214.     sync_m68k_pc();
  2215.     printf("\tmmu_op(opcode,extra);\n");
  2216.     break;
  2217.      default:
  2218.     abort();
  2219.     break;
  2220.     };
  2221.     finish_braces ();
  2222.     sync_m68k_pc ();
  2223.     printf("%s: (void)0;\n", endlabelstr);
  2224. }
  2225.  
  2226. static void generate_func(int range)
  2227. {
  2228.     int illg = 0;
  2229.     long int opcode;
  2230.     int i, rp;
  2231.     uae_u16 smsk;
  2232.     uae_u16 dmsk;
  2233.  
  2234.     printf("#include \"sysconfig.h\"\n");
  2235.     printf("#include \"sysdeps.h\"\n");
  2236.     printf("#include \"config.h\"\n");
  2237.     printf("#include \"options.h\"\n");
  2238.     printf("#include \"machdep/m68k.h\"\n");
  2239.     printf("#include \"memory.h\"\n");
  2240.     printf("#include \"custom.h\"\n");
  2241.     printf("#include \"readcpu.h\"\n");
  2242.     printf("#include \"newcpu.h\"\n");
  2243.     printf("#include \"compiler.h\"\n");
  2244.     printf("#include \"cputbl.h\"\n");
  2245.  
  2246.     for(rp = range_start[range]; rp < range_start[range+1]; rp++) {
  2247.     opcode = opcode_map[rp];
  2248.     if (table68k[opcode].mnemo == i_ILLG) {
  2249.         illg++;
  2250.         continue;
  2251.     }
  2252.     for (i = 0 ; lookuptab[i].name[0] ; i++) {
  2253.         if (table68k[opcode].mnemo == lookuptab[i].mnemo)
  2254.         break;
  2255.     }
  2256.  
  2257.     if (table68k[opcode].handler != -1)
  2258.         continue;
  2259.  
  2260.     switch (table68k[opcode].stype) {
  2261.      case 0:
  2262.         smsk = 7; break;
  2263.      case 1:
  2264.         smsk = 255; break;
  2265.      case 2:
  2266.         smsk = 15; break;
  2267.      case 3:
  2268.         smsk = 7; break;
  2269.      case 4:
  2270.         smsk = 7; break;
  2271.      case 5:
  2272.         smsk = 63; break;
  2273.      default:
  2274.         abort();
  2275.     }
  2276.     dmsk = 7;
  2277.  
  2278.     printf("void REGPARAM2 CPU_OP_NAME(_%lx)(uae_u32 opcode) /* %s */\n{\n", opcode, lookuptab[i].name);
  2279.     if (table68k[opcode].suse
  2280.         && table68k[opcode].smode != imm  && table68k[opcode].smode != imm0
  2281.         && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
  2282.         && table68k[opcode].smode != absw && table68k[opcode].smode != absl
  2283.         && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
  2284.     {
  2285.         if (table68k[opcode].spos == -1) {
  2286.         if (((int)table68k[opcode].sreg) >= 128)
  2287.             printf("\tuae_u32 srcreg = (uae_s32)(uae_s8)%d;\n", (int)table68k[opcode].sreg);
  2288.         else
  2289.             printf("\tuae_u32 srcreg = %d;\n", (int)table68k[opcode].sreg);
  2290.         } else {
  2291.         char source[100];
  2292.  
  2293.         if (table68k[opcode].spos)
  2294.             sprintf(source,"((opcode >> %d) & %d)",(int)table68k[opcode].spos,smsk);
  2295.         else
  2296.             sprintf(source,"(opcode & %d)",smsk);
  2297.  
  2298.         if (table68k[opcode].stype == 3)
  2299.             printf("\tuae_u32 srcreg = imm8_table[%s];\n", source);
  2300.         else if (table68k[opcode].stype == 1)
  2301.             printf("\tuae_u32 srcreg = (uae_s32)(uae_s8)%s;\n", source);
  2302.         else
  2303.             printf("\tuae_u32 srcreg = %s;\n", source);
  2304.         }
  2305.     }
  2306.     if (table68k[opcode].duse
  2307.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  2308.         && table68k[opcode].dmode != imm  && table68k[opcode].dmode != imm0
  2309.         && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
  2310.         && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
  2311.         if (table68k[opcode].dpos == -1) {
  2312.         if (((int)table68k[opcode].dreg) >= 128)
  2313.             printf("\tuae_u32 dstreg = (uae_s32)(uae_s8)%d;\n", (int)table68k[opcode].dreg);
  2314.         else
  2315.             printf("\tuae_u32 dstreg = %d;\n", (int)table68k[opcode].dreg);
  2316.         } else {
  2317.         if (table68k[opcode].dpos)
  2318.             printf("\tuae_u32 dstreg = (opcode >> %d) & %d;\n",
  2319.                 (int)table68k[opcode].dpos,dmsk);
  2320.         else
  2321.             printf("\tuae_u32 dstreg = opcode & %d;\n", dmsk);
  2322.         }
  2323.     }
  2324.     endlabelno++;
  2325.     sprintf(endlabelstr, "endlabel%d", endlabelno);
  2326.     gen_opcode(opcode);
  2327.     printf("}\n");
  2328.     }
  2329.     fprintf (stderr, "%d illegals generated.\n", illg);
  2330. }
  2331.  
  2332. static void generate_table(void)
  2333. {
  2334.     int illg = 0;
  2335.     long int opcode;
  2336.  
  2337.     printf("#include \"sysconfig.h\"\n");
  2338.     printf("#include \"sysdeps.h\"\n");
  2339.     printf("#include \"config.h\"\n");
  2340.     printf("#include \"options.h\"\n");
  2341.     printf("#include \"machdep/m68k.h\"\n");
  2342.     printf("#include \"memory.h\"\n");
  2343.     printf("#include \"custom.h\"\n");
  2344.     printf("#include \"readcpu.h\"\n");
  2345.     printf("#include \"newcpu.h\"\n");
  2346.     printf("#include \"compiler.h\"\n");
  2347.     printf("#include \"cputbl.h\"\n");
  2348.  
  2349.     printf("cpuop_func *CPU_OP_NAME(_functbl)[65536] = {\n");
  2350.     for(opcode=0; opcode < 65536; opcode++) {
  2351.     if (table68k[opcode].mnemo == i_ILLG) {
  2352.         printf("op_illg");
  2353.         illg++;
  2354.     } else if (table68k[opcode].handler != -1)
  2355.         printf("CPU_OP_NAME(_%lx)", table68k[opcode].handler);
  2356.     else
  2357.         printf("CPU_OP_NAME(_%lx)", opcode);
  2358.  
  2359.     if (opcode < 65535) printf(",");
  2360.     if ((opcode & 7) == 7) printf("\n");
  2361.     }
  2362.     printf("\n};\n");
  2363.     fprintf (stderr, "%d illegals generated.\n", illg);
  2364.     if (get_no_mismatches())
  2365.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  2366. }
  2367.  
  2368. static void generate_smalltable(void)
  2369. {
  2370.     long int opcode;
  2371.     int i;
  2372.  
  2373.     printf("#include \"sysconfig.h\"\n");
  2374.     printf("#include \"sysdeps.h\"\n");
  2375.     printf("#include \"config.h\"\n");
  2376.     printf("#include \"options.h\"\n");
  2377.     printf("#include \"machdep/m68k.h\"\n");
  2378.     printf("#include \"memory.h\"\n");
  2379.     printf("#include \"custom.h\"\n");
  2380.     printf("#include \"readcpu.h\"\n");
  2381.     printf("#include \"newcpu.h\"\n");
  2382.     printf("#include \"compiler.h\"\n");
  2383.     printf("#include \"cputbl.h\"\n");
  2384.  
  2385.     printf("struct cputbl CPU_OP_NAME(_smalltbl)[] = {\n");
  2386.  
  2387.     for(opcode=0; opcode < 65536; opcode++) {
  2388.     if (table68k[opcode].handler == -1 && table68k[opcode].mnemo != i_ILLG)
  2389.     {
  2390.         for (i = 0 ; lookuptab[i].name[0] ; i++) {
  2391.         if (table68k[opcode].mnemo == lookuptab[i].mnemo)
  2392.             break;
  2393.         }
  2394.         if (table68k[opcode].handler == -1)
  2395.         printf("{ CPU_OP_NAME(_%lx), 0, %ld }, /* %s */\n", opcode, opcode, lookuptab[i].name);
  2396.     }
  2397.     }
  2398.     printf("{ 0, 0, 0 }};\n");
  2399. }
  2400.  
  2401. static void generate_header(void)
  2402. {
  2403.     int illg = 0;
  2404.     long int opcode;
  2405.  
  2406.     for(opcode=0; opcode < 65536; opcode++) {
  2407.     if (table68k[opcode].mnemo == i_ILLG) {
  2408.         illg++;
  2409.         continue;
  2410.     }
  2411.     if (table68k[opcode].handler != -1)
  2412.         continue;
  2413.  
  2414.     printf("extern cpuop_func CPU_OP_NAME(_%lx);\n", opcode);
  2415.     }
  2416.  
  2417.     fprintf (stderr, "%d illegals generated.\n", illg);
  2418.     if (get_no_mismatches())
  2419.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  2420. }
  2421.  
  2422. int main(int argc, char **argv)
  2423. {
  2424.     long int range = -1;
  2425.     char mode = 'n';
  2426.  
  2427.     if (argc == 2)
  2428.     mode = *argv[1];
  2429.  
  2430.     if (argc == 3) {
  2431.     range = atoi(argv[2]);
  2432.     mode = *argv[1];
  2433.     }
  2434.  
  2435.     read_table68k ();
  2436.     do_merges ();
  2437.  
  2438.     opcode_map = (int *)xmalloc (sizeof (int) * nr_cpuop_funcs);
  2439.     read_counts();
  2440.  
  2441.     switch(mode) {
  2442.      case 'f':
  2443.     generate_func(range);
  2444.     break;
  2445.      case 'h':
  2446.     generate_header();
  2447.     break;
  2448.      case 't':
  2449.     generate_table();
  2450.     break;
  2451.      case 's':
  2452.     generate_smalltable();
  2453.     break;
  2454.      default:
  2455.     abort();
  2456.     }
  2457.     free(table68k);
  2458.     return 0;
  2459. }
  2460.